mirror of
https://github.com/curioustorvald/Terrarum.git
synced 2026-03-13 15:16:07 +09:00
removing unused libs
This commit is contained in:
minjaesong
@@ -196,30 +196,6 @@ Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
|
||||
|
||||
$BULLET Jdsp
|
||||
|
||||
Copyright (c) 2019 Sambit Paul
|
||||
|
||||
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.
|
||||
|
||||
|
||||
|
||||
$BULLET Apache Commons Codec
|
||||
|
||||
Copyright 2002-2023 The Apache Software Foundation
|
||||
@@ -251,6 +227,49 @@ Copyright 2010-2012 CS Systèmes d'Information
|
||||
|
||||
|
||||
|
||||
$BULLET JTransforms
|
||||
|
||||
Copyright (c) 2007 onward, Piotr Wendykier
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
|
||||
$BULLET Aircompressor
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
||||
|
||||
|
||||
$BULLET Ambient sound recordings:
|
||||
|
||||
- ambient_forest_01.ogg
|
||||
|
||||
@@ -2,8 +2,6 @@ package net.torvald.terrarum.audio
|
||||
|
||||
import com.badlogic.gdx.utils.Disposable
|
||||
import net.torvald.terrarum.App
|
||||
import org.apache.commons.math3.transform.DftNormalization
|
||||
import org.apache.commons.math3.transform.TransformType
|
||||
import org.jtransforms.fft.FloatFFT_1D
|
||||
|
||||
private val RE0 = 0
|
||||
@@ -65,7 +63,7 @@ private val mulBuf = FloatArray(2)
|
||||
}
|
||||
|
||||
/**
|
||||
* Modification of the code form JDSP and Apache Commons Math
|
||||
* Helper object to call JTransforms
|
||||
*
|
||||
* Created by minjaesong on 2023-11-25.
|
||||
*/
|
||||
@@ -86,57 +84,13 @@ object FFT: Disposable {
|
||||
|
||||
|
||||
init {
|
||||
// Loader.load(org.bytedeco.fftw.global.fftw3::class.java)
|
||||
|
||||
App.disposables.add(this)
|
||||
}
|
||||
|
||||
/*private val reLock = ReentrantLock(true)
|
||||
|
||||
private fun getForwardPlan(n: Int, inn: FloatArray, out: FloatArray): fftwf_plan {
|
||||
return fftwf_plan_dft_1d(n, inn, out, FFTW_FORWARD, FFTW_ESTIMATE)
|
||||
}
|
||||
private fun getBackwardPlan(n: Int, inn: FloatArray, out: FloatArray): fftwf_plan {
|
||||
return fftwf_plan_dft_1d(n, inn, out, FFTW_BACKWARD, FFTW_ESTIMATE)
|
||||
}
|
||||
private fun destroyPlan(plan: fftwf_plan) {
|
||||
fftwf_destroy_plan(plan)
|
||||
}*/
|
||||
|
||||
override fun dispose() {
|
||||
}
|
||||
|
||||
// org.apache.commons.math3.transform.FastFouriesTransformer.java:370
|
||||
fun fft(signal0: FloatArray): ComplexArray {
|
||||
// val im = FloatArray(signal0.size)
|
||||
// transformInPlace(signal0, im, signal0.size, DftNormalization.STANDARD, TransformType.FORWARD)
|
||||
// return ComplexArray(FloatArray(signal0.size) { if (it % 2 == 0) signal0[it / 2] else im[it / 2] })
|
||||
|
||||
|
||||
// USING FFTW //
|
||||
/*lateinit var retObj: ComplexArray
|
||||
reLock.lock {
|
||||
fftw_init_threads()
|
||||
|
||||
val signal = FloatArray(2 * signal0.size)
|
||||
val result = FloatArray(2 * signal0.size)
|
||||
|
||||
val plan = getForwardPlan(signal0.size, signal, result)
|
||||
|
||||
signal0.forEachIndexed { index, fl -> signal[index * 2] = fl }
|
||||
|
||||
fftwf_execute(plan)
|
||||
|
||||
retObj = ComplexArray(result)
|
||||
|
||||
destroyPlan(plan)
|
||||
|
||||
fftwf_cleanup_threads()
|
||||
}
|
||||
return retObj*/
|
||||
|
||||
|
||||
// USING JTRANSFORMS //
|
||||
val signal = FloatArray(signal0.size * 2) { if (it % 2 == 0) signal0[it / 2] else 0f }
|
||||
ffts[signal0.size]!!.complexForward(signal)
|
||||
return ComplexArray(signal)
|
||||
@@ -151,36 +105,7 @@ object FFT: Disposable {
|
||||
ffts[signal0.size]!!.complexForward(out.reim)
|
||||
}
|
||||
|
||||
// org.apache.commons.math3.transform.FastFouriesTransformer.java:404
|
||||
fun ifftAndGetReal(signal0: ComplexArray): FloatArray {
|
||||
// val re = FloatArray(signal0.size) { signal0.reim[it * 2] }
|
||||
// val im = FloatArray(signal0.size) { signal0.reim[it * 2 + 1] }
|
||||
// transformInPlace(re, im, re.size, DftNormalization.STANDARD, TransformType.INVERSE)
|
||||
// return re
|
||||
|
||||
|
||||
// USING FFTW //
|
||||
/*lateinit var re: FloatArray
|
||||
reLock.lock {
|
||||
fftw_init_threads()
|
||||
|
||||
val signal = signal0.reim
|
||||
val result = FloatArray(2 * signal0.size)
|
||||
|
||||
val plan = getBackwardPlan(signal0.size, signal, result)
|
||||
|
||||
fftwf_execute(plan)
|
||||
|
||||
re = FloatArray(signal0.size) { result[it * 2] }
|
||||
|
||||
destroyPlan(plan)
|
||||
|
||||
fftwf_cleanup_threads()
|
||||
}
|
||||
return re*/
|
||||
|
||||
|
||||
// USING JTRANSFORMS //
|
||||
ffts[signal0.size]!!.complexInverse(signal0.reim, true)
|
||||
return signal0.getReal()
|
||||
}
|
||||
@@ -191,230 +116,4 @@ object FFT: Disposable {
|
||||
output[i] = signal0.reim[i * 2]
|
||||
}
|
||||
}
|
||||
|
||||
// org.apache.commons.math3.transform.FastFouriesTransformer.java:214
|
||||
/**
|
||||
* Computes the standard transform of the specified complex data. The
|
||||
* computation is done in place. The input data is laid out as follows
|
||||
* <ul>
|
||||
* <li>{@code dataRI[0][i]} is the real part of the {@code i}-th data point,</li>
|
||||
* <li>{@code dataRI[1][i]} is the imaginary part of the {@code i}-th data point.</li>
|
||||
* </ul>
|
||||
*
|
||||
* @param dataRI the two dimensional array of real and imaginary parts of the data
|
||||
* @param normalization the normalization to be applied to the transformed data
|
||||
* @param type the type of transform (forward, inverse) to be performed
|
||||
* @throws DimensionMismatchException if the number of rows of the specified
|
||||
* array is not two, or the array is not rectangular
|
||||
* @throws MathIllegalArgumentException if the number of data points is not
|
||||
* a power of two
|
||||
*/
|
||||
private fun transformInPlace(dataR: FloatArray, dataI: FloatArray, n: Int, normalization: DftNormalization, type: TransformType) {
|
||||
|
||||
/*if (n == 1) {
|
||||
return
|
||||
}
|
||||
else if (n == 2) {
|
||||
val srcR0 = dataR[0]
|
||||
val srcI0 = dataI[0]
|
||||
val srcR1 = dataR[1]
|
||||
val srcI1 = dataI[1]
|
||||
|
||||
// X_0 = x_0 + x_1
|
||||
dataR[0] = srcR0 + srcR1
|
||||
dataI[0] = srcI0 + srcI1
|
||||
// X_1 = x_0 - x_1
|
||||
dataR[1] = srcR0 - srcR1
|
||||
dataI[1] = srcI0 - srcI1
|
||||
normalizeTransformedData(dataRI, normalization, type)
|
||||
return
|
||||
}*/
|
||||
|
||||
bitReversalShuffle2(dataR, dataI)
|
||||
|
||||
// Do 4-term DFT.
|
||||
if (type == TransformType.INVERSE) {
|
||||
var i0 = 0
|
||||
while (i0 < n) {
|
||||
val i1 = i0 + 1
|
||||
val i2 = i0 + 2
|
||||
val i3 = i0 + 3
|
||||
val srcR0 = dataR[i0]
|
||||
val srcI0 = dataI[i0]
|
||||
val srcR1 = dataR[i2]
|
||||
val srcI1 = dataI[i2]
|
||||
val srcR2 = dataR[i1]
|
||||
val srcI2 = dataI[i1]
|
||||
val srcR3 = dataR[i3]
|
||||
val srcI3 = dataI[i3]
|
||||
|
||||
// 4-term DFT
|
||||
// X_0 = x_0 + x_1 + x_2 + x_3
|
||||
dataR[i0] = srcR0 + srcR1 + srcR2 + srcR3
|
||||
dataI[i0] = srcI0 + srcI1 + srcI2 + srcI3
|
||||
// X_1 = x_0 - x_2 + j * (x_3 - x_1)
|
||||
dataR[i1] = srcR0 - srcR2 + (srcI3 - srcI1)
|
||||
dataI[i1] = srcI0 - srcI2 + (srcR1 - srcR3)
|
||||
// X_2 = x_0 - x_1 + x_2 - x_3
|
||||
dataR[i2] = srcR0 - srcR1 + srcR2 - srcR3
|
||||
dataI[i2] = srcI0 - srcI1 + srcI2 - srcI3
|
||||
// X_3 = x_0 - x_2 + j * (x_1 - x_3)
|
||||
dataR[i3] = srcR0 - srcR2 + (srcI1 - srcI3)
|
||||
dataI[i3] = srcI0 - srcI2 + (srcR3 - srcR1)
|
||||
i0 += 4
|
||||
}
|
||||
}
|
||||
else {
|
||||
var i0 = 0
|
||||
while (i0 < n) {
|
||||
val i1 = i0 + 1
|
||||
val i2 = i0 + 2
|
||||
val i3 = i0 + 3
|
||||
val srcR0 = dataR[i0]
|
||||
val srcI0 = dataI[i0]
|
||||
val srcR1 = dataR[i2]
|
||||
val srcI1 = dataI[i2]
|
||||
val srcR2 = dataR[i1]
|
||||
val srcI2 = dataI[i1]
|
||||
val srcR3 = dataR[i3]
|
||||
val srcI3 = dataI[i3]
|
||||
|
||||
// 4-term DFT
|
||||
// X_0 = x_0 + x_1 + x_2 + x_3
|
||||
dataR[i0] = srcR0 + srcR1 + srcR2 + srcR3
|
||||
dataI[i0] = srcI0 + srcI1 + srcI2 + srcI3
|
||||
// X_1 = x_0 - x_2 + j * (x_3 - x_1)
|
||||
dataR[i1] = srcR0 - srcR2 + (srcI1 - srcI3)
|
||||
dataI[i1] = srcI0 - srcI2 + (srcR3 - srcR1)
|
||||
// X_2 = x_0 - x_1 + x_2 - x_3
|
||||
dataR[i2] = srcR0 - srcR1 + srcR2 - srcR3
|
||||
dataI[i2] = srcI0 - srcI1 + srcI2 - srcI3
|
||||
// X_3 = x_0 - x_2 + j * (x_1 - x_3)
|
||||
dataR[i3] = srcR0 - srcR2 + (srcI3 - srcI1)
|
||||
dataI[i3] = srcI0 - srcI2 + (srcR1 - srcR3)
|
||||
i0 += 4
|
||||
}
|
||||
}
|
||||
|
||||
var lastN0 = 4
|
||||
var lastLogN0 = 2
|
||||
while (lastN0 < n) {
|
||||
val n0 = lastN0 shl 1
|
||||
val logN0 = lastLogN0 + 1
|
||||
val wSubN0R = W_SUB_N_R[logN0]
|
||||
var wSubN0I = W_SUB_N_I[logN0]
|
||||
if (type == TransformType.INVERSE) {
|
||||
wSubN0I = -wSubN0I
|
||||
}
|
||||
|
||||
// Combine even/odd transforms of size lastN0 into a transform of size N0 (lastN0 * 2).
|
||||
var destEvenStartIndex = 0
|
||||
while (destEvenStartIndex < n) {
|
||||
val destOddStartIndex = destEvenStartIndex + lastN0
|
||||
var wSubN0ToRR = 1f
|
||||
var wSubN0ToRI = 0f
|
||||
for (r in 0 until lastN0) {
|
||||
val grR = dataR[destEvenStartIndex + r]
|
||||
val grI = dataI[destEvenStartIndex + r]
|
||||
val hrR = dataR[destOddStartIndex + r]
|
||||
val hrI = dataI[destOddStartIndex + r]
|
||||
|
||||
// dest[destEvenStartIndex + r] = Gr + WsubN0ToR * Hr
|
||||
dataR[destEvenStartIndex + r] = grR + wSubN0ToRR * hrR - wSubN0ToRI * hrI
|
||||
dataI[destEvenStartIndex + r] = grI + wSubN0ToRR * hrI + wSubN0ToRI * hrR
|
||||
// dest[destOddStartIndex + r] = Gr - WsubN0ToR * Hr
|
||||
dataR[destOddStartIndex + r] = grR - (wSubN0ToRR * hrR - wSubN0ToRI * hrI)
|
||||
dataI[destOddStartIndex + r] = grI - (wSubN0ToRR * hrI + wSubN0ToRI * hrR)
|
||||
|
||||
// WsubN0ToR *= WsubN0R
|
||||
val nextWsubN0ToRR = wSubN0ToRR * wSubN0R - wSubN0ToRI * wSubN0I
|
||||
val nextWsubN0ToRI = wSubN0ToRR * wSubN0I + wSubN0ToRI * wSubN0R
|
||||
wSubN0ToRR = nextWsubN0ToRR
|
||||
wSubN0ToRI = nextWsubN0ToRI
|
||||
}
|
||||
destEvenStartIndex += n0
|
||||
}
|
||||
lastN0 = n0
|
||||
lastLogN0 = logN0
|
||||
}
|
||||
|
||||
normalizeTransformedData(dataR, dataI, n, normalization, type)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Applies the proper normalization to the specified transformed data.
|
||||
*
|
||||
* @param dataRI the unscaled transformed data
|
||||
* @param normalization the normalization to be applied
|
||||
* @param type the type of transform (forward, inverse) which resulted in the specified data
|
||||
*/
|
||||
private fun normalizeTransformedData(
|
||||
dataR: FloatArray, dataI: FloatArray, n: Int,
|
||||
normalization: DftNormalization, type: TransformType
|
||||
) {
|
||||
// assert(dataI.size == n)
|
||||
// when (normalization) {
|
||||
// DftNormalization.STANDARD ->
|
||||
if (type == TransformType.INVERSE) {
|
||||
val scaleFactor = 1f / n.toFloat()
|
||||
var i = 0
|
||||
while (i < n) {
|
||||
dataR[i] *= scaleFactor
|
||||
dataI[i] *= scaleFactor
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
/* DftNormalization.UNITARY -> {
|
||||
val scaleFactor = (1.0 / FastMath.sqrt(n.toDouble())).toFloat()
|
||||
var i = 0
|
||||
while (i < n) {
|
||||
dataR[i] *= scaleFactor
|
||||
dataI[i] *= scaleFactor
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
else -> throw MathIllegalStateException()
|
||||
}*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs identical index bit reversal shuffles on two arrays of identical
|
||||
* size. Each element in the array is swapped with another element based on
|
||||
* the bit-reversal of the index. For example, in an array with length 16,
|
||||
* item at binary index 0011 (decimal 3) would be swapped with the item at
|
||||
* binary index 1100 (decimal 12).
|
||||
*
|
||||
* @param a the first array to be shuffled
|
||||
* @param b the second array to be shuffled
|
||||
*/
|
||||
private fun bitReversalShuffle2(a: FloatArray, b: FloatArray) {
|
||||
val n = a.size
|
||||
assert(b.size == n)
|
||||
val halfOfN = n shr 1
|
||||
var j = 0
|
||||
for (i in 0 until n) {
|
||||
if (i < j) {
|
||||
// swap indices i & j
|
||||
var temp = a[i]
|
||||
a[i] = a[j]
|
||||
a[j] = temp
|
||||
temp = b[i]
|
||||
b[i] = b[j]
|
||||
b[j] = temp
|
||||
}
|
||||
var k = halfOfN
|
||||
while (k in 1..j) {
|
||||
j -= k
|
||||
k = k shr 1
|
||||
}
|
||||
j += k
|
||||
}
|
||||
}
|
||||
|
||||
private val W_SUB_N_R = FFTConsts.W_SUB_N_R.map { it.toFloat() }.toFloatArray()
|
||||
private val W_SUB_N_I = FFTConsts.W_SUB_N_I.map { it.toFloat() }.toFloatArray()
|
||||
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
package net.torvald.terrarum.audio;
|
||||
|
||||
/**
|
||||
* Created by minjaesong on 2023-11-25.
|
||||
*/
|
||||
public class FFTConsts {
|
||||
|
||||
// org.apache.commons.math3.transform.FastFouriesTransformer.java:58
|
||||
/**
|
||||
* {@code W_SUB_N_R[i]} is the real part of
|
||||
* {@code exp(- 2 * i * pi / n)}:
|
||||
* {@code W_SUB_N_R[i] = cos(2 * pi/ n)}, where {@code n = 2^i}.
|
||||
*/
|
||||
public static final double[] W_SUB_N_R =
|
||||
{ 0x1.0p0, -0x1.0p0, 0x1.1a62633145c07p-54, 0x1.6a09e667f3bcdp-1
|
||||
, 0x1.d906bcf328d46p-1, 0x1.f6297cff75cbp-1, 0x1.fd88da3d12526p-1, 0x1.ff621e3796d7ep-1
|
||||
, 0x1.ffd886084cd0dp-1, 0x1.fff62169b92dbp-1, 0x1.fffd8858e8a92p-1, 0x1.ffff621621d02p-1
|
||||
, 0x1.ffffd88586ee6p-1, 0x1.fffff62161a34p-1, 0x1.fffffd8858675p-1, 0x1.ffffff621619cp-1
|
||||
, 0x1.ffffffd885867p-1, 0x1.fffffff62161ap-1, 0x1.fffffffd88586p-1, 0x1.ffffffff62162p-1
|
||||
, 0x1.ffffffffd8858p-1, 0x1.fffffffff6216p-1, 0x1.fffffffffd886p-1, 0x1.ffffffffff621p-1
|
||||
, 0x1.ffffffffffd88p-1, 0x1.fffffffffff62p-1, 0x1.fffffffffffd9p-1, 0x1.ffffffffffff6p-1
|
||||
, 0x1.ffffffffffffep-1, 0x1.fffffffffffffp-1, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
|
||||
, 0x1.0p0, 0x1.0p0, 0x1.0p0 };
|
||||
|
||||
/**
|
||||
* {@code W_SUB_N_I[i]} is the imaginary part of
|
||||
* {@code exp(- 2 * i * pi / n)}:
|
||||
* {@code W_SUB_N_I[i] = -sin(2 * pi/ n)}, where {@code n = 2^i}.
|
||||
*/
|
||||
public static final double[] W_SUB_N_I =
|
||||
{ 0x1.1a62633145c07p-52, -0x1.1a62633145c07p-53, -0x1.0p0, -0x1.6a09e667f3bccp-1
|
||||
, -0x1.87de2a6aea963p-2, -0x1.8f8b83c69a60ap-3, -0x1.917a6bc29b42cp-4, -0x1.91f65f10dd814p-5
|
||||
, -0x1.92155f7a3667ep-6, -0x1.921d1fcdec784p-7, -0x1.921f0fe670071p-8, -0x1.921f8becca4bap-9
|
||||
, -0x1.921faaee6472dp-10, -0x1.921fb2aecb36p-11, -0x1.921fb49ee4ea6p-12, -0x1.921fb51aeb57bp-13
|
||||
, -0x1.921fb539ecf31p-14, -0x1.921fb541ad59ep-15, -0x1.921fb5439d73ap-16, -0x1.921fb544197ap-17
|
||||
, -0x1.921fb544387bap-18, -0x1.921fb544403c1p-19, -0x1.921fb544422c2p-20, -0x1.921fb54442a83p-21
|
||||
, -0x1.921fb54442c73p-22, -0x1.921fb54442cefp-23, -0x1.921fb54442d0ep-24, -0x1.921fb54442d15p-25
|
||||
, -0x1.921fb54442d17p-26, -0x1.921fb54442d18p-27, -0x1.921fb54442d18p-28, -0x1.921fb54442d18p-29
|
||||
, -0x1.921fb54442d18p-30, -0x1.921fb54442d18p-31, -0x1.921fb54442d18p-32, -0x1.921fb54442d18p-33
|
||||
, -0x1.921fb54442d18p-34, -0x1.921fb54442d18p-35, -0x1.921fb54442d18p-36, -0x1.921fb54442d18p-37
|
||||
, -0x1.921fb54442d18p-38, -0x1.921fb54442d18p-39, -0x1.921fb54442d18p-40, -0x1.921fb54442d18p-41
|
||||
, -0x1.921fb54442d18p-42, -0x1.921fb54442d18p-43, -0x1.921fb54442d18p-44, -0x1.921fb54442d18p-45
|
||||
, -0x1.921fb54442d18p-46, -0x1.921fb54442d18p-47, -0x1.921fb54442d18p-48, -0x1.921fb54442d18p-49
|
||||
, -0x1.921fb54442d18p-50, -0x1.921fb54442d18p-51, -0x1.921fb54442d18p-52, -0x1.921fb54442d18p-53
|
||||
, -0x1.921fb54442d18p-54, -0x1.921fb54442d18p-55, -0x1.921fb54442d18p-56, -0x1.921fb54442d18p-57
|
||||
, -0x1.921fb54442d18p-58, -0x1.921fb54442d18p-59, -0x1.921fb54442d18p-60 };
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user