//b == Cosh(a)
//c == Sinh(a)
public static void CoshSinh(Complex a, out Complex b, out Complex c)
{
Complex d, e;
Exp(a, out d, out e);
b = (d + e) / 2;
c = (d - e) / 2;
}
// compute the FFT of x[], assuming its length is a power of 2
public static Complex[] fft(Complex[] x)
{
int N = x.Length;
// base case
if (N == 1) return new Complex[] { x[0] };
// radix 2 Cooley-Tukey FFT
if (N % 2 != 0) { throw new Exception("N is not a power of 2"); }
// fft of even terms
Complex[] even = new Complex[N/2];
for (int k = 0; k < N/2; k++) {
even[k] = x[2*k];
}
Complex[] q = fft(even);
// fft of odd terms
Complex[] odd = even; // reuse the array
for (int k = 0; k < N/2; k++) {
odd[k] = x[2*k + 1];
}
Complex[] r = fft(odd);
// combine
Complex[] y = new Complex[N];
for (int k = 0; k < N/2; k++) {
double kth = -2 * k * Math.PI / N;
Complex wk = new Complex(Math.Cos(kth), Math.Sin(kth));
Complex tmp = wk * r[k];
y[k] = q[k] + tmp;
y[k + N/2] = q[k] - tmp;
}
return y;
}
public static Complex[] FFT(float[] samples)
{
//Debug.Assert((samples.Length & (samples.Length - 1)) == 0);
//FIXME: what happens if I pass non power of 2??
#if false
Func<int, int, double> window_fn = FastFourierTransform.HammingWindow;
#else
Func<int, int, double> window_fn = (a, b) => 1;
#endif
Complex[] fftData = new Complex[samples.Length];
for (int i = 0; i < samples.Length; ++i)
{
fftData[i].X = (float) (samples[i] * window_fn(i, samples.Length));
fftData[i].Y = 0;
}
/* in-place, forwards FFT.
* Input is a sequence of complex numbers with sample amplitude in the real part and a 0 imaginary part.
* Output is a sequence of complex numbers, whose modulus is the amplitude at that frequency.
* Outputs range in frequency from 0 to sample rate
*/
FastFourierTransform.FFT(true, (int) Math.Log(fftData.Length, 2), fftData);
return fftData;
}
//b == Exp(a)
//c == 1/Exp(a)
public static void Exp(Complex a, out Complex b, out Complex c)
{
double d = Math.Exp(a.Real);
Complex e = new Complex(Math.Cos(a.Imaginary), Math.Sin(a.Imaginary));
b = e * d;
c = b.Reciprocal();
}
public override void addOpperand(Calc calc,Complex c)
{
//calc.Opperand1=calc.Total;
//calc.Opperand2=c;
calc.Total=c;
calc.CurrentState=OpperandEnteredState.Singleton;
}
/// <summary>
/// Computes an Fast Fourier Transform.
/// </summary>
/// <param name="data">Array of complex numbers. This array provides the input data and is used to store the result of the FFT.</param>
/// <param name="exponent">The exponent n.</param>
/// <param name="mode">The <see cref="FftMode"/> to use. Use <see cref="FftMode.Forward"/> as the default value.</param>
public static void Fft(Complex[] data, int exponent, FftMode mode = FftMode.Forward)
{
//count; if exponent = 12 -> c = 2^12 = 4096
int c = (int)Math.Pow(2, exponent);
//binary inversion
Inverse(data, c);
int j0, j1, j2 = 1;
float n0, n1, tr, ti, m;
float v0 = -1, v1 = 0;
//move to outer scope to optimize performance
int j, i;
for (int l = 0; l < exponent; l++)
{
n0 = 1;
n1 = 0;
j1 = j2;
j2 <<= 1; //j2 * 2
for (j = 0; j < j1; j++)
{
for (i = j; i < c; i += j2)
{
j0 = i + j1;
//--
tr = n0 * data[j0].Real - n1 * data[j0].Imaginary;
ti = n0 * data[j0].Imaginary + n1 * data[j0].Real;
//--
data[j0].Real = data[i].Real - tr;
data[j0].Imaginary = data[i].Imaginary - ti;
//add
data[i].Real += tr;
data[i].Imaginary += ti;
}
//calc coeff
m = v0 * n0 - v1 * n1;
n1 = v1 * n0 + v0 * n1;
n0 = m;
}
if (mode == FftMode.Forward)
{
v1 = (float)Math.Sqrt((1f - v0) / 2f);
}
else
{
v1 = (float)-Math.Sqrt((1f - v0) / 2f);
}
v0 = (float)Math.Sqrt((1f + v0) / 2f);
}
if (mode == FftMode.Forward)
{
Forward(data, c);
}
}
public static Complex Tanh(Complex z)
{
double x = Math.Tanh(z.Re);
double y = Math.Tan(z.Im);
return new Complex(x, y) / new Complex(1, x * y);
}
public Complex response(double freq)
{
int i;
Complex rnum = 0;
Complex rden = 0;
Complex[] omega = new Complex[s.Length];
Complex z = Complex.Exp(new Complex(0, 2 * Math.PI * freq));
omega[0] = 1.0;
omega[1] = z;
for (i = 2; i < s.Length; i++)
omega[i] = omega[i - 1] * z;
for (i = 0; i < a.Length; i++)
rnum += a[i] * omega[i];
rden = omega[0];
for (i = 1; i < b.Length; i++)
rden += b[i] * omega[i];
if (rden.Magnitude == 0)
{
return Double.MaxValue;
}
else
{
return rnum / rden;
}
}
public Hash(Complex[][] comData)
{
this.comData = comData;
width = comData.Length;
if (width != 0)
height = 600;
}
public static void RunTests_BoundaryValues()
{
// Verify test results with Max
Complex max = new Complex(double.MaxValue, double.MaxValue);
Complex complexExp = Complex.Exp(max);
Support.VerifyRealImaginaryProperties(complexExp, Math.Cos(double.MaxValue) * double.PositiveInfinity, double.PositiveInfinity,
string.Format("Exp(Max) is not (Infinity, Infinity)"));
// Verify test results with MaxReal
Complex maxReal = new Complex(double.MaxValue, 0.0);
complexExp = Complex.Exp(max);
Support.VerifyRealImaginaryProperties(complexExp, Math.Cos(double.MaxValue) * double.PositiveInfinity, double.PositiveInfinity,
string.Format("Exp(MaxReal) is not (Infinity, Infinity))"));
// Verify test results with MaxImg
VerifyExpWithAddition(0.0, double.MaxValue);
// Verify test results with Min
VerifyExpWithAddition(double.MinValue, double.MinValue);
// Verify test results with MinReal
VerifyExpWithAddition(double.MinValue, 0.0);
// Verify test results with MinImaginary
VerifyExpWithAddition(0.0, double.MinValue);
}
public JuliaWithClouds(ulong IterCount, double LeftEdge, double RightEdge, double TopEdge, double BottomEdge, Complex ComplexConst,int MaxAmmountAtTrace=100,int AbcissStepSize=20,int OrdinateStepSize=20)
: base(IterCount,LeftEdge,RightEdge,TopEdge,BottomEdge,ComplexConst)
{
_max_ammount_at_trace = MaxAmmountAtTrace;
_abciss_step_length = AbcissStepSize;
_ordinate_step_length = OrdinateStepSize;
}
/// <summary>
/// Clamp elements in the complex array to range [minimum,maximum]
/// </summary>
/// <param name="array"></param>
/// <param name="minimum"></param>
/// <param name="maximum"></param>
public static void Clamp( Complex[] array, Complex minimum, Complex maximum )
{
for( int i = 0; i < array.Length; i ++ ) {
array[i].Re = Math.Min( Math.Max( array[ i ].Re, minimum.Re ), maximum.Re );
array[i].Im = Math.Min( Math.Max( array[ i ].Re, minimum.Im ), maximum.Im );
}
}
private static void VerifyFactoryMethod(double magnitude, double phase)
{
double m = magnitude;
double p = phase;
Complex c_new = Complex.FromPolarCoordinates(magnitude, phase);
//Double.IsNaN(magnitude) is checked in the verifiation method.
if (Double.IsNaN(phase) || Double.IsInfinity(phase))
{
magnitude = Double.NaN;
phase = Double.NaN;
}
// Special check in Complex.Abs method
else if (Double.IsInfinity(magnitude))
{
magnitude = Double.PositiveInfinity;
phase = Double.NaN;
}
if (false == Support.VerifyMagnitudePhaseProperties(c_new, magnitude, phase))
{
Console.WriteLine("Error_89fdl!!! FromPolorCoordinates: ({0}, {1})", m, p);
Assert.True(false, "Verification Failed");
}
else // if the first verification returns TrUe, do the second one!
{
Complex c_new_ctor = new Complex(c_new.Real, c_new.Imaginary);
if (false == Support.VerifyMagnitudePhaseProperties(c_new_ctor, magnitude, phase))
{
Console.WriteLine("Error_fs46!!! FromPolorCoordinates: ({0}, {1})", m, p);
Assert.True(false, "Verification Failed");
}
}
}
}//multiply
public cFloat divide(cFloat c1, cFloat c2){
Complex comp1 = new Complex(c1.getReal(), c1.getImg());
Complex comp2 = new Complex(c2.getReal(), c1.getImg());
Complex comp3 = comp1 / comp2;
return new cFloat((float)comp3.Real, (float)comp3.Imaginary);
}//divide
public static void Start(Random rnd)
{
int length = 4096;
var masComplex1 = new Complex[length];
var masSimdComplex1 = new Vector2[length];
var masComplex2 = new Complex[length];
var masSimdComplex2 = new Vector2[length];
for (int i = 0; i < length; i++)
{
float v1 = (float) rnd.NextDouble()*1000;
float v2 = (float) rnd.NextDouble()*1000;
masComplex1[i] = new Complex(v1, v2);
masSimdComplex1[i] = new Vector2(v1,v2);
v1 = (float)rnd.NextDouble() * 1000;
v2 = (float)rnd.NextDouble() * 1000;
masComplex2[i] = new Complex(v1, v2);
masSimdComplex2[i] = new Vector2(v1, v2);
}
Extensions.TestTime(() =>
TestWithoutSimd(masComplex1, masComplex2),
"Время для complex ");
Extensions.TestTime(() =>
TestWithSimd(masSimdComplex1, masSimdComplex2),
"Время для complex(simd) ");
}
public void Update(Complex[] fftResults)
{
// no need to repaint too many frames per second
if (updateCount++ % 2 == 0)
{
return;
}
if (fftResults.Length / 2 != bins)
{
this.bins = fftResults.Length / 2;
CalculateXScale();
}
for (int n = 0; n < fftResults.Length / 2; n+= binsPerPoint)
{
// averaging out bins
double yPos = 0;
for (int b = 0; b < binsPerPoint; b++)
{
yPos += GetYPosLog(fftResults[n+b]);
}
AddResult(n / binsPerPoint, yPos / binsPerPoint);
}
}
public void processData(ref Complex[][] res, ref int resLen)
{
resLen = 0;
int channels = 2;
int pbs = 4096*2*channels;
for(int i = 0; i<len/pbs; i++)
{
comData = new Complex[10000];
comLen = 0;
for (int j = i*pbs, cur = 0; j < (i+1)*pbs; j+=2*channels, cur++)
{
float sum = 0;
for (int k = 0; k < channels; k++)
sum += (buf[j + 2 * k + 1] << 8) | (buf[j + 2 * k]);
sum /= channels;
comData[comLen].X = sum;
comData[comLen].X *= (float)FastFourierTransform.HammingWindow(cur, 4096);
comData[comLen].Y = 0;
comLen++;
}
FastFourierTransform.FFT(true, 12, comData);
res[resLen] = comData;
resLen++;
}
resLen++;
resLen--;
}
public void ToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Reciprocal(new ComplexNumber(complex));
Assert.Equal("reciprocal(3.1+2.5i)", exp.ToString());
}
public override void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x, Complex[] result)
{
if (y == null)
{
throw new ArgumentNullException("y");
}
if (x == null)
{
throw new ArgumentNullException("x");
}
if (y.Length != x.Length)
{
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
if (!ReferenceEquals(y, result))
{
Array.Copy(y, 0, result, 0, y.Length);
}
if (alpha == Complex.Zero)
{
return;
}
SafeNativeMethods.z_axpy(y.Length, alpha, x, result);
}
private static void VerifySqrtWithRectangularForm(Double real, Double imaginary)
{
// sqrt(a+bi) = +- (sqrt(r + a) + i sqrt(r - a) sign(b)) sqrt(2) / 2, unless a=-r and y = 0
Complex complex = new Complex(real, imaginary);
Double expectedReal = 0.0;
Double expectedImaginary = 0.0;
if (0 == imaginary)
{
if (real == -complex.Magnitude)
expectedImaginary = Math.Sqrt(-real);
else
expectedReal = Math.Sqrt(real);
}
else
{
Double scale = 1 / Math.Sqrt(2);
expectedReal = scale * Math.Sqrt(complex.Magnitude + complex.Real);
expectedImaginary = scale * Math.Sqrt(complex.Magnitude - complex.Real);
if (complex.Imaginary < 0)
{
expectedImaginary = -expectedImaginary;
}
}
VerifySqrtWithRectangularForm(real, imaginary, expectedReal, expectedImaginary);
}
public void ExecuteTest1()
{
var complex = new Complex(3.1, 2.5);
var exp = new Reciprocal(new ComplexNumber(complex));
Assert.Equal(Complex.Reciprocal(complex), exp.Execute());
}
/// <summary>
/// Gets the correlation.
/// </summary>
/// <param name="originalVector">The original vector.</param>
/// <param name="correlationVector">The correlation vector.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Different length of vectors</exception>
public static Complex[] GetCorrelation(Complex[] originalVector, Complex[] correlationVector)
{
if (originalVector.Length != correlationVector.Length)
{
throw new ArgumentException("Different length of vectors");
}
CorrelationComplexibility = 0;
// ReSharper disable once InconsistentNaming
var N = originalVector.Length;
var result = new Complex[N];
for (var i = 0; i < N; i++)
{
for (var j = 0; j < N; j++)
{
if (i + j < N)
{
result[i] += originalVector[j] * correlationVector[i + j];
CorrelationComplexibility++;
}
else
{
result[i] += originalVector[j] * correlationVector[i + j - N];
CorrelationComplexibility++;
}
}
result[i] /= N;
}
return result;
}
//---------------------------------------------------------------------------------------------
/// <summary>
/// Clamp length (modulus) of the elements in the complex array
/// </summary>
/// <param name = "array"></param>
/// <param name = "fMinimum"></param>
/// <param name = "fMaximum"></param>
public static void ClampLength(Complex[] array, double fMinimum, double fMaximum)
{
for (int i = 0; i < array.Length; i++)
{
array[i] = Complex.FromModulusArgument(Math.Max(fMinimum, Math.Min(fMaximum, array[i].GetModulus())), array[i].GetArgument());
}
}
public static Complex operator +(Complex c1, Complex c2)
{
int cnt = c1.b * c2.b;
int sum = c2.b * c1.a + c1.b * c2.a;
if (cnt > sum)
{
for (int i = sum; i > 2; i--)
{
if (cnt % i == 0 && sum % i == 0)
{
cnt = cnt / i;
sum = sum / i;
break;
}
}
}
else
{
for (int i = cnt; i > 2; i--)
{
if (cnt % i == 0 && sum % i == 0)
{
cnt = cnt / i;
sum = sum / i;
break;
}
}
}
Complex c3 = new Complex(sum, cnt);
return c3;
}
static void Main(string[] args)
{
Complex c1 = new Complex(1, 2);
Complex c2 = new Complex(1, 2);
Complex c3 = new Complex();
Console.WriteLine(c1);
Console.WriteLine(c2);
Console.WriteLine(c3);
Complex c4 = c1.Add(c2);
Console.WriteLine(c4);
Complex c5 = c2.Subtract(c1);
Console.WriteLine(c5);
Complex c6 = c1.Multiply(c2);
Console.WriteLine(c6);
if(c1.Equals(c2))
Console.WriteLine("c1 este egal cu c2");
else
Console.WriteLine("c1 nu este egal cu c2");
}
public void ExecuteWithParamsTest()
{
var complex = new Complex(5, 2);
var exp = new ComplexNumber(complex);
Assert.Equal(complex, exp.Execute(null));
}
public void SetVar(string varname, Complex value)
{
var root = Root;
if (root.m_variables == null)
root.m_variables = new Dictionary<string, Complex>();
root.m_variables[varname.ToLower()] = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserQR"/> class. This object will compute the
/// QR factorization when the constructor is called and cache it's factorization.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <param name="method">The QR factorization method to use.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
public static UserQR Create(Matrix<Complex> matrix, QRMethod method = QRMethod.Full)
{
if (matrix.RowCount < matrix.ColumnCount)
{
throw Matrix.DimensionsDontMatch<ArgumentException>(matrix);
}
Matrix<Complex> q;
Matrix<Complex> r;
var minmn = Math.Min(matrix.RowCount, matrix.ColumnCount);
var u = new Complex[minmn][];
if (method == QRMethod.Full)
{
r = matrix.Clone();
q = Matrix<Complex>.Build.SameAs(matrix, matrix.RowCount, matrix.RowCount);
for (var i = 0; i < matrix.RowCount; i++)
{
q.At(i, i, 1.0f);
}
for (var i = 0; i < minmn; i++)
{
u[i] = GenerateColumn(r, i, i);
ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
}
for (var i = minmn - 1; i >= 0; i--)
{
ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
}
}
else
{
q = matrix.Clone();
for (var i = 0; i < minmn; i++)
{
u[i] = GenerateColumn(q, i, i);
ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
}
r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
q.Clear();
for (var i = 0; i < matrix.ColumnCount; i++)
{
q.At(i, i, 1.0f);
}
for (var i = minmn - 1; i >= 0; i--)
{
ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
}
}
return new UserQR(q, r, method);
}
public void ExecuteTest()
{
var complex = new Complex(5, 2);
var exp = new ComplexNumber(complex);
Assert.Equal(complex, exp.Execute());
}
private static void VerifyBinaryMultiplyResult(Double realFirst, Double imgFirst, Double realSecond, Double imgSecond)
{
// calculate the expected results
Double realExpectedResult = realFirst * realSecond - imgFirst * imgSecond;
Double imaginaryExpectedResult = realFirst * imgSecond + imgFirst * realSecond;
// Create complex numbers
Complex cFirst = new Complex(realFirst, imgFirst);
Complex cSecond = new Complex(realSecond, imgSecond);
// arithmetic multiply (binary) operation
Complex cResult = cFirst * cSecond;
// verify the result
if (false == Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult))
{
Console.WriteLine("ErRoR! Binary Multiply Error!");
Console.WriteLine("Binary Multiply test = ({0}, {1}) * ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond);
Assert.True(false, "Verification Failed");
}
// arithmetic multiply (static) operation
cResult = Complex.Multiply(cFirst, cSecond);
// verify the result
if (false == Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult))
{
Console.WriteLine("ErRoR! Multiply (Static) Error!");
Console.WriteLine("Multiply (Static) test = ({0}, {1}) * ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond);
Assert.True(false, "Verification Failed");
}
}
private static Complex Sin(Complex[] args) => Complex.Sin(args.Check(1)[0]);
// Two-argument functions
private static Complex Pow(Complex[] args)
{
args.Check(2); return(Complex.Pow(args[0], args[1]));
}
private static Complex Exp(Complex[] args) => Complex.Exp(args.Check(1)[0]);
private static Complex Tanh(Complex[] args) => Complex.Tanh(args.Check(1)[0]);
private static Complex Cosh(Complex[] args) => Complex.Cosh(args.Check(1)[0]);
private static Complex Atan(Complex[] args) => Complex.Atan(args.Check(1)[0]);
private static Complex Acos(Complex[] args) => Complex.Acos(args.Check(1)[0]);
internal static extern void z_axpy(IntPtr blasHandle, int n, Complex alpha, Complex[] x, [In, Out] Complex[] y);
private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
{
byte[] buffer = e.Buffer;
int bytesGrabados = e.BytesRecorded;
int numMuestras = bytesGrabados / 2;
int exponente = 0;
int numeroBits = 0;
do
{
exponente++;
numeroBits = (int)Math.Pow(2, exponente);
} while (numeroBits < numMuestras);
exponente -= 1;
numeroBits = (int)Math.Pow(2, exponente);
Complex[] muestrasComplejas = new Complex[numeroBits];
for (int i = 0; i < bytesGrabados; i += 2)
{
short muestra = (short)(buffer[i + 1] << 8 | buffer[i]);
float muestra32bits = (float)muestra / 32768.0f;
if (i / 2 < numeroBits)
{
muestrasComplejas[i / 2].X = muestra32bits;
}
}
FastFourierTransform.FFT(true, exponente, muestrasComplejas);
float[] valoresAbsolutos = new float[muestrasComplejas.Length];
for (int i = 0; i < muestrasComplejas.Length; i++)
{
valoresAbsolutos[i] = (float)Math.Sqrt(((muestrasComplejas[i].X * muestrasComplejas[i].X) + (muestrasComplejas[i].Y * muestrasComplejas[i].Y)));
}
int indiceValorMaximo = valoresAbsolutos.ToList().IndexOf(valoresAbsolutos.Max());
float frecuenciaFundamental = (float)(indiceValorMaximo * formato.SampleRate) / (float)valoresAbsolutos.Length;
lblFrecuencia.Text = frecuenciaFundamental.ToString("n") + " Hz";
/* Aqui se modificann los valores para que hagan lo de apretar o aflojar la cuerda */
//Inicio de la cuerda 6
if (frecuenciaFundamental >= 149 && frecuenciaFundamental <= 159) //esta floja
{
lblTono.Text = "Eb";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 169 && frecuenciaFundamental <= 179) //esta tensa
{
lblTono.Text = "E#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 160 && frecuenciaFundamental <= 168) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "E";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 6";
}
//Fin de la cuerda 6
//comienzo de la cuerda 5
else if (frecuenciaFundamental >= 204 && frecuenciaFundamental <= 214) //esta floja
{
lblTono.Text = "Ab";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 226 && frecuenciaFundamental <= 236) //esta tensa
{
lblTono.Text = "A#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 215 && frecuenciaFundamental <= 225) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "A";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 5";
}
//fin de la cuerda 5
//inicia la 4
else if (frecuenciaFundamental >= 276 && frecuenciaFundamental <= 286) //esta floja
{
lblTono.Text = "Db";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 298 && frecuenciaFundamental <= 308) //esta tensa
{
lblTono.Text = "D#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 287 && frecuenciaFundamental <= 297) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "D";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 4";
}
//termina la 4
//inicia la 3
else if (frecuenciaFundamental >= 180 && frecuenciaFundamental <= 190) //esta floja
{
lblTono.Text = "Gb";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 198 && frecuenciaFundamental <= 203) //esta tensa
{
lblTono.Text = "G#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 191 && frecuenciaFundamental <= 197) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "G";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 3";
}
//termina la 3
//inicia la 2
else if (frecuenciaFundamental >= 237 && frecuenciaFundamental <= 242) //esta floja
{
lblTono.Text = "Bb";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 250 && frecuenciaFundamental <= 260) //esta tensa
{
lblTono.Text = "B#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 243 && frecuenciaFundamental <= 249) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "B";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 2";
}
//termina la 2
//comienza la 1
else if (frecuenciaFundamental >= 313 && frecuenciaFundamental <= 323) //esta floja
{
lblTono.Text = "eb";
imgFlechaDerecha.Visibility = Visibility.Visible;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 333 && frecuenciaFundamental <= 343) //esta tensa
{
lblTono.Text = "e#";
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Visible;
lblTono.Foreground = Brushes.Gray;
}
else if (frecuenciaFundamental >= 324 && frecuenciaFundamental <= 332) //esta al toque prro
{
imgFlechaDerecha.Visibility = Visibility.Hidden;
imgFlechaIzquierda.Visibility = Visibility.Hidden;
lblTono.Text = "e";
lblTono.Foreground = Brushes.Green;
lblCuerda.Text = "Cuerda 1";
}
/* Aquí termina el codigo de mostrar la nota */
}
internal static extern void z_scale(IntPtr blasHandle, int n, Complex alpha, [In, Out] Complex[] x);
// Onset Detection function - Determines Start and Finish times of a note and the frequency of the note over each duration.
private void onsetDetection()
{
float[] HFC;
int starts = 0;
int stops = 0;
List <int> lengths;
List <int> noteStarts;
List <int> noteStops;
double pi = 3.14159265;
Complex i = Complex.ImaginaryOne;
double[] pitches = new double[100];
noteStarts = new List <int>(100);
noteStops = new List <int>(100);
lengths = new List <int>(100);
SolidColorBrush sheetBrush = new SolidColorBrush(Colors.Black);
SolidColorBrush ErrorBrush = new SolidColorBrush(Colors.Red);
SolidColorBrush whiteBrush = new SolidColorBrush(Colors.White);
HFC = new float[stftRep.timeFreqData[0].Length];
////////////////////////////////////////////////////////////////////////
/// Parallel Section ///
////////////////////////////////////////////////////////////////////////
// Original and Chunked are slower
//for (int jj = 0; jj < stftRep.timeFreqData[0].Length; jj++)
//{
// for (int ii = 0; ii < stftRep.wSamp / 2; ii++)
// {
// HFC[jj] = HFC[jj] + (float)Math.Pow((double)stftRep.timeFreqData[ii][jj] * ii, 2);
// }
//}
int N = stftRep.timeFreqData[0].Length;
Parallel.For(0, NUM_THREADS_USED, iterator =>
{
int chunk_size = (N + (NUM_THREADS_USED - 1)) / NUM_THREADS_USED;
int start = chunk_size * iterator;
int end = Math.Min(start + chunk_size, N);
for (int jj = start; jj < end; jj++)
{
for (int ii = 0; ii < stftRep.wSamp / 2; ii++)
{
HFC[jj] = HFC[jj] + (float)Math.Pow((double)stftRep.timeFreqData[ii][jj] * ii, 2);
}
}
});
//Parallel.For(0, stftRep.timeFreqData[0].Length, jj =>
//{
// for (int ii = 0; ii < stftRep.wSamp / 2; ii++)
// {
// HFC[jj] = HFC[jj] + (float)Math.Pow((double)stftRep.timeFreqData[ii][jj] * ii, 2);
// }
//});
////////////////////////////// ~ END ~ /////////////////////////////////
float maxi = HFC.Max();
for (int jj = 0; jj < stftRep.timeFreqData[0].Length; jj++)
{
HFC[jj] = (float)Math.Pow((HFC[jj] / maxi), 2);
}
for (int jj = 0; jj < stftRep.timeFreqData[0].Length; jj++)
{
if (starts > stops)
{
if (HFC[jj] < 0.001)
{
noteStops.Add(jj * ((stftRep.wSamp - 1) / 2));
stops = stops + 1;
}
}
else if (starts - stops == 0)
{
if (HFC[jj] > 0.001)
{
noteStarts.Add(jj * ((stftRep.wSamp - 1) / 2));
starts = starts + 1;
}
}
}
if (starts > stops)
{
noteStops.Add(waveIn.data.Length);
}
for (int ii = 0; ii < noteStops.Count; ii++)
{
lengths.Add(noteStops[ii] - noteStarts[ii]);
}
////////////////////////////////////////////////////////////////////////
/// Parallel Section ///
////////////////////////////////////////////////////////////////////////
//Seq in other folder. Due to restructuring
Parallel.For(0, NUM_THREADS_USED, iterator =>
{
int guardSize = lengths.Count;
int chunkSize = (guardSize + (NUM_THREADS_USED - 1)) / NUM_THREADS_USED;
int start = chunkSize * iterator;
int end = Math.Min(start + chunkSize, guardSize);
for (int mm = start; mm < end; mm++)
{
Complex[] twiddles;
Complex[] compX;
Complex[] Y;
double[] absY;
int nearest = (int)Math.Pow(2, Math.Ceiling(Math.Log(lengths[mm], 2)));
twiddles = new Complex[nearest];
for (int ll = 0; ll < nearest; ll++)
{
double a = 2 * pi * ll / (double)nearest;
twiddles[ll] = Complex.Pow(Complex.Exp(-i), (float)a);
}
compX = new Complex[nearest];
for (int kk = 0; kk < nearest; kk++)
{
if (kk < lengths[mm] && (noteStarts[mm] + kk) < waveIn.wave.Length)
{
compX[kk] = waveIn.wave[noteStarts[mm] + kk];
}
else
{
compX[kk] = Complex.Zero;
}
}
Y = new Complex[nearest];
Y = fft(compX, nearest, twiddles);
double maximum = 0;
int maxInd = 0;
absY = new double[nearest];
for (int jj = 0; jj < Y.Length; jj++)
{
absY[jj] = Y[jj].Magnitude;
if (absY[jj] > maximum)
{
maximum = absY[jj];
maxInd = jj;
}
}
for (int div = 6; div > 1; div--)
{
if (maxInd > nearest / 2)
{
if (absY[(int)Math.Floor((double)(nearest - maxInd) / div)] / absY[(maxInd)] > 0.10)
{
maxInd = (nearest - maxInd) / div;
}
}
else
{
if (absY[(int)Math.Floor((double)maxInd / div)] / absY[(maxInd)] > 0.10)
{
maxInd = maxInd / div;
}
}
}
if (maxInd > nearest / 2)
{
pitches[mm] = (nearest - maxInd) * waveIn.SampleRate / nearest;
}
else
{
pitches[mm] = maxInd * waveIn.SampleRate / nearest;
}
}
});
//Parallel.For(0, lengths.Count, mm =>
//{
// Complex[] twiddles;
// Complex[] compX;
// Complex[] Y;
// double[] absY;
// int nearest = (int)Math.Pow(2, Math.Ceiling(Math.Log(lengths[mm], 2)));
// twiddles = new Complex[nearest];
// for (int ll = 0; ll < nearest; ll++)
// {
// double a = 2 * pi * ll / (double)nearest;
// twiddles[ll] = Complex.Pow(Complex.Exp(-i), (float)a);
// }
// compX = new Complex[nearest];
// for (int kk = 0; kk < nearest; kk++)
// {
// if (kk < lengths[mm] && (noteStarts[mm] + kk) < waveIn.wave.Length)
// {
// compX[kk] = waveIn.wave[noteStarts[mm] + kk];
// }
// else
// {
// compX[kk] = Complex.Zero;
// }
// }
// Y = new Complex[nearest];
// Y = fft(compX, nearest, twiddles);
// double maximum = 0;
// int maxInd = 0;
// absY = new double[nearest];
// for (int jj = 0; jj < Y.Length; jj++)
// {
// absY[jj] = Y[jj].Magnitude;
// if (absY[jj] > maximum)
// {
// maximum = absY[jj];
// maxInd = jj;
// }
// }
// for (int div = 6; div > 1; div--)
// {
// if (maxInd > nearest / 2)
// {
// if (absY[(int)Math.Floor((double)(nearest - maxInd) / div)] / absY[(maxInd)] > 0.10)
// {
// maxInd = (nearest - maxInd) / div;
// }
// }
// else
// {
// if (absY[(int)Math.Floor((double)maxInd / div)] / absY[(maxInd)] > 0.10)
// {
// maxInd = maxInd / div;
// }
// }
// }
// if (maxInd > nearest / 2)
// {
// pitches[mm] = (nearest - maxInd) * waveIn.SampleRate / nearest;
// }
// else
// {
// pitches[mm] = maxInd * waveIn.SampleRate / nearest;
// }
//});
////////////////////////////// ~ END ~ /////////////////////////////////
musicNote[] noteArray;
noteArray = new musicNote[noteStarts.Count()];
for (int ii = 0; ii < noteStarts.Count(); ii++)
{
noteArray[ii] = new musicNote(pitches[ii], lengths[ii]);
}
int[] sheetPitchArray = new int[sheetmusic.Length];
int[] notePitchArray = new int[noteArray.Length];
for (int ii = 0; ii < sheetmusic.Length; ii++)
{
sheetPitchArray[ii] = sheetmusic[ii].pitch % 12;
}
for (int jj = 0; jj < noteArray.Length; jj++)
{
notePitchArray[jj] = noteArray[jj].pitch % 12;
}
string[] alignedStrings = new string[2];
alignedStrings = stringMatch(sheetPitchArray, notePitchArray);
musicNote[] alignedStaffArray = new musicNote[alignedStrings[0].Length / 2];
musicNote[] alignedNoteArray = new musicNote[alignedStrings[1].Length / 2];
int staffCount = 0;
int noteCount = 0;
for (int ii = 0; ii < alignedStrings[0].Length / 2; ii++)
{
if (alignedStrings[0][2 * ii] == ' ')
{
alignedStaffArray[ii] = new musicNote(0, 0);
}
else
{
alignedStaffArray[ii] = sheetmusic[staffCount];
staffCount++;
}
if (alignedStrings[1][2 * ii] == ' ')
{
alignedNoteArray[ii] = new musicNote(0, 0);
}
else
{
alignedNoteArray[ii] = noteArray[noteCount];
noteCount++;
}
}
// STAFF TAB DISPLAY -- Commented out to make timing consistant.
//Ellipse[] notes;
//Line[] stems;
//notes = new Ellipse[alignedNoteArray.Length];
//stems = new Line[alignedNoteArray.Length];
//SolidColorBrush myBrush = new SolidColorBrush(Colors.Green);
//RotateTransform rotate = new RotateTransform(45);
//for (int ii = 0; ii < alignedNoteArray.Length; ii++)
//{
// //noteArray[ii] = new musicNote(pitches[ii], lengths[ii]);
// //System.Console.Out.Write("Note " + (ii + 1) + ": \nDuration: " + noteArray[ii].duration / waveIn.SampleRate + " seconds \nPitch: " + Enum.GetName(typeof(musicNote.notePitch), (noteArray[ii].pitch) % 12) + " / " + pitches[ii] + "\nError: " + noteArray[ii].error * 100 + "%\n");
// notes[ii] = new Ellipse();
// notes[ii].Tag = alignedNoteArray[ii];
// notes[ii].Height = 20;
// notes[ii].Width = 15;
// notes[ii].Margin = new Thickness(ii * 30, 0, 0, 0);
// notes[ii].LayoutTransform = rotate;
// notes[ii].MouseEnter += DisplayStats;
// notes[ii].MouseLeave += ClearStats;
// stems[ii] = new Line();
// stems[ii].StrokeThickness = 1;
// stems[ii].X1 = ii * 30 + 20;
// stems[ii].X2 = ii * 30 + 20;
// stems[ii].Y1 = 250 - 10 * alignedNoteArray[ii].staffPos;
// stems[ii].Y2 = 250 - 10 * alignedNoteArray[ii].staffPos - 40;
// notes[ii].Fill = ErrorBrush;
// notes[ii].StrokeThickness = 1;
// stems[ii].Stroke = ErrorBrush;
// Canvas.SetTop(notes[ii], (240 - 10 * alignedNoteArray[ii].staffPos));
// if (alignedNoteArray[ii].flat)
// {
// System.Windows.Controls.Label flat = new System.Windows.Controls.Label();
// flat.Content = "b";
// flat.FontFamily = new FontFamily("Mistral");
// flat.Margin = new Thickness(ii * 30 + 15, 0, 0, 0);
// Canvas.SetTop(flat, (240 - 10 * alignedNoteArray[ii].staffPos));
// noteStaff.Children.Insert(ii, flat);
// }
// noteStaff.Children.Insert(ii, notes[ii]);
// noteStaff.Children.Insert(ii, stems[ii]);
//}
//Ellipse[] sheetNotes;
//Rectangle[] timeRect;
//Line[] sheetStems;
//sheetNotes = new Ellipse[alignedStaffArray.Length];
//sheetStems = new Line[alignedStaffArray.Length];
//timeRect = new Rectangle[2 * alignedStaffArray.Length];
//Fline.Width = alignedStaffArray.Length * 30;
//Dline.Width = alignedStaffArray.Length * 30;
//Bline.Width = alignedStaffArray.Length * 30;
//Gline.Width = alignedStaffArray.Length * 30;
//Eline.Width = alignedStaffArray.Length * 30;
//noteStaff.Width = alignedStaffArray.Length * 30;
//for (int ii = 0; ii < alignedStaffArray.Length; ii++)
//{
// sheetNotes[ii] = new Ellipse();
// sheetNotes[ii].Tag = alignedStaffArray[ii];
// sheetNotes[ii].Height = 20;
// sheetNotes[ii].Width = 15;
// sheetNotes[ii].Margin = new Thickness(ii * 30, 0, 0, 0);
// sheetNotes[ii].LayoutTransform = rotate;
// sheetNotes[ii].MouseEnter += DisplayStats;
// sheetNotes[ii].MouseLeave += ClearStats;
// sheetStems[ii] = new Line();
// sheetStems[ii].StrokeThickness = 1;
// sheetStems[ii].X1 = ii * 30 + 20;
// sheetStems[ii].X2 = ii * 30 + 20;
// sheetStems[ii].Y1 = 250 - 10 * alignedStaffArray[ii].staffPos;
// sheetStems[ii].Y2 = 250 - 10 * alignedStaffArray[ii].staffPos - 40;
// sheetNotes[ii].Fill = sheetBrush;
// sheetNotes[ii].StrokeThickness = 1;
// sheetStems[ii].Stroke = sheetBrush;
// Canvas.SetTop(sheetNotes[ii], (240 - 10 * alignedStaffArray[ii].staffPos));
// if (alignedStaffArray[ii].flat)
// {
// System.Windows.Controls.Label flat = new System.Windows.Controls.Label();
// flat.Content = "b";
// flat.FontFamily = new FontFamily("Mistral");
// flat.Margin = new Thickness(ii * 30 + 15, 0, 0, 0);
// Canvas.SetTop(flat, (240 - 10 * alignedStaffArray[ii].staffPos));
// noteStaff.Children.Insert(ii, flat);
// }
// noteStaff.Children.Insert(ii, sheetNotes[ii]);
// noteStaff.Children.Insert(ii, sheetStems[ii]);
//}
//// FOR TIMING ERROR RECTANGLES
//for (int ii = 0; ii < alignedStaffArray.Length; ii++)
//{
// timeRect[ii] = new Rectangle();
// timeRect[ii].Fill = sheetBrush;
// timeRect[ii].Height = 10 * alignedStaffArray[ii].duration * 4 * bpm / (60 * waveIn.SampleRate);
// timeRect[ii].Width = 15;
// timeRect[ii].Margin = new Thickness(ii * 30 + 5, 0, 0, 0);
// Canvas.SetTop(timeRect[ii], 200);
// noteStaff.Children.Insert(ii, timeRect[ii]);
//}
//for (int ii = alignedStaffArray.Length; ii < alignedStaffArray.Length + alignedNoteArray.Length; ii++)
//{
// timeRect[ii] = new Rectangle();
// timeRect[ii].Fill = ErrorBrush;
// timeRect[ii].Height = 10 * alignedNoteArray[ii - alignedStaffArray.Length].duration * 4 * bpm / (60 * waveIn.SampleRate);
// timeRect[ii].Width = 10;
// timeRect[ii].Margin = new Thickness((ii - alignedStaffArray.Length) * 30 + 5, 0, 0, 0);
// Canvas.SetTop(timeRect[ii], 200);
// noteStaff.Children.Insert(ii, timeRect[ii]);
//}
}
internal static extern void z_matrix_multiply(IntPtr blasHandle, int transA, int transB, int m, int n, int k, Complex alpha, Complex[] x, Complex[] y, Complex beta, [In, Out] Complex[] c);
/// <summary>
/// Solves a system of linear equations, <b>Ax = b</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side vector, <b>b</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>x</b>.</param>
public override void Solve(Vector <Complex> input, Vector <Complex> result)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
// Ax=b where A is an m x n matrix
// Check that b is a column vector with m entries
if (MatrixQ.RowCount != input.Count)
{
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
// Check that x is a column vector with n entries
if (MatrixQ.ColumnCount != result.Count)
{
throw Matrix.DimensionsDontMatch <ArgumentException>(MatrixQ, result);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new Complex[MatrixQ.RowCount];
for (var k = 0; k < MatrixQ.RowCount; k++)
{
column[k] = inputCopy[k];
}
for (var i = 0; i < MatrixQ.ColumnCount; i++)
{
var s = Complex.Zero;
for (var k = 0; k < MatrixQ.RowCount; k++)
{
s += MatrixQ.At(k, i).Conjugate() * column[k];
}
inputCopy[i] = s;
}
// Solve R*X = Y;
for (var k = MatrixQ.ColumnCount - 1; k >= 0; k--)
{
inputCopy[k] /= MatrixR.At(k, k);
for (var i = 0; i < k; i++)
{
inputCopy[i] -= inputCopy[k] * MatrixR.At(i, k);
}
}
for (var i = 0; i < MatrixR.ColumnCount; i++)
{
result[i] = inputCopy[i];
}
}
internal override void InitVelocityConstraints(ref SolverData data)
{
_indexA = BodyA.IslandIndex;
_indexB = BodyB.IslandIndex;
_localCenterA = BodyA._sweep.LocalCenter;
_localCenterB = BodyB._sweep.LocalCenter;
_invMassA = BodyA._invMass;
_invMassB = BodyB._invMass;
_invIA = BodyA._invI;
_invIB = BodyB._invI;
Vector2 cA = data.positions[_indexA].c;
float aA = data.positions[_indexA].a;
Vector2 vA = data.velocities[_indexA].v;
float wA = data.velocities[_indexA].w;
Vector2 cB = data.positions[_indexB].c;
float aB = data.positions[_indexB].a;
Vector2 vB = data.velocities[_indexB].v;
float wB = data.velocities[_indexB].w;
Complex qA = Complex.FromAngle(aA);
Complex qB = Complex.FromAngle(aB);
_rA = Complex.Multiply(LocalAnchorA - _localCenterA, ref qA);
_rB = Complex.Multiply(LocalAnchorB - _localCenterB, ref qB);
_u = cB + _rB - cA - _rA;
// Handle singularity.
float length = _u.Length();
if (length > Settings.LinearSlop)
{
_u *= 1.0f / length;
}
else
{
_u = Vector2.Zero;
}
float crAu = MathUtils.Cross(ref _rA, ref _u);
float crBu = MathUtils.Cross(ref _rB, ref _u);
float invMass = _invMassA + _invIA * crAu * crAu + _invMassB + _invIB * crBu * crBu;
// Compute the effective mass matrix.
_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
if (Frequency > 0.0f)
{
float C = length - Length;
// Frequency
float omega = 2.0f * MathHelper.Pi * Frequency;
// Damping coefficient
float d = 2.0f * _mass * DampingRatio * omega;
// Spring stiffness
float k = _mass * omega * omega;
// magic formulas
float h = data.step.dt;
_gamma = h * (d + h * k);
_gamma = _gamma != 0.0f ? 1.0f / _gamma : 0.0f;
_bias = C * h * k * _gamma;
invMass += _gamma;
_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
}
else
{
_gamma = 0.0f;
_bias = 0.0f;
}
if (data.step.warmStarting)
{
// Scale the impulse to support a variable time step.
_impulse *= data.step.dtRatio;
Vector2 P = _impulse * _u;
vA -= _invMassA * P;
wA -= _invIA * MathUtils.Cross(ref _rA, ref P);
vB += _invMassB * P;
wB += _invIB * MathUtils.Cross(ref _rB, ref P);
}
else
{
_impulse = 0.0f;
}
data.velocities[_indexA].v = vA;
data.velocities[_indexA].w = wA;
data.velocities[_indexB].v = vB;
data.velocities[_indexB].w = wB;
}
// this is to allow saving of large arrays separately as a binary file
public BinaryArraySerializer[] GetBinarySerializers()
{
return(new[]
{
new BinaryArraySerializer
{
DataArray = Mean,
Name = "Mean",
FileTag = "",
WriteData = binaryWriter =>
{
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < MTBins.Count - 1; j++)
{
binaryWriter.Write(Mean[i, j].Real);
binaryWriter.Write(Mean[i, j].Imaginary);
}
}
},
ReadData = binaryReader =>
{
Mean = Mean ?? new Complex[Fx.Count, MTBins.Count - 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < MTBins.Count - 1; j++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
Mean[i, j] = new Complex(real, imag);
}
}
}
},
new BinaryArraySerializer
{
DataArray = FractionalMT,
Name = "FractionalMT",
FileTag = "_FractionalMT",
WriteData = binaryWriter =>
{
for (int i = 0; i < Fx.Count; i++)
{
for (int k = 0; k < MTBins.Count - 1; k++)
{
for (int m = 0; m < FractionalMTBins.Count + 1; m++)
{
binaryWriter.Write(FractionalMT[i, k, m].Real);
binaryWriter.Write(FractionalMT[i, k, m].Imaginary);
}
}
}
},
ReadData = binaryReader =>
{
FractionalMT = FractionalMT ??
new Complex[Fx.Count, MTBins.Count - 1, FractionalMTBins.Count + 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int k = 0; k < MTBins.Count - 1; k++)
{
for (int m = 0; m < FractionalMTBins.Count + 1; m++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
FractionalMT[i, k, m] = new Complex(real, imag);
}
}
}
}
},
new BinaryArraySerializer
{
DataArray = TotalMTOfZ,
Name = "TotalMTOfZ",
FileTag = "_TotalMTOfZ",
WriteData = binaryWriter =>
{
for (int i = 0; i < Fx.Count; i++)
{
for (int l = 0; l < Z.Count - 1; l++)
{
binaryWriter.Write(TotalMTOfZ[i, l].Real);
binaryWriter.Write(TotalMTOfZ[i, l].Imaginary);
}
}
},
ReadData = binaryReader =>
{
TotalMTOfZ = TotalMTOfZ ?? new Complex[Fx.Count, Z.Count - 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int l = 0; l < Z.Count - 1; l++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
TotalMTOfZ[i, l] = new Complex(real, imag);
}
}
}
},
new BinaryArraySerializer
{
DataArray = DynamicMTOfZ,
Name = "DynamicMTOfZ",
FileTag = "_DynamicMTOfZ",
WriteData = binaryWriter =>
{
for (int i = 0; i < Fx.Count; i++)
{
for (int l = 0; l < Z.Count - 1; l++)
{
binaryWriter.Write(DynamicMTOfZ[i, l].Real);
binaryWriter.Write(DynamicMTOfZ[i, l].Imaginary);
}
}
},
ReadData = binaryReader =>
{
DynamicMTOfZ = DynamicMTOfZ ?? new Complex[Fx.Count, Z.Count - 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int l = 0; l < Z.Count - 1; l++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
DynamicMTOfZ[i, l] = new Complex(real, imag);
}
}
}
},
new BinaryArraySerializer
{
DataArray = SubregionCollisions,
Name = "SubregionCollisions",
FileTag = "_SubregionCollisions",
WriteData = binaryWriter =>
{
for (int i = 0; i < NumSubregions; i++)
{
for (int l = 0; l < 2; l++)
{
binaryWriter.Write(SubregionCollisions[i, l]);
}
}
},
ReadData = binaryReader =>
{
SubregionCollisions = SubregionCollisions ??
new double[NumSubregions, 2];
for (int i = 0; i < NumSubregions; i++)
{
for (int l = 0; l < 2; l++)
{
SubregionCollisions[i, l] = binaryReader.ReadDouble();
}
}
}
},
// return a null serializer, if we're not serializing the second moment
!TallySecondMoment
? null
: new BinaryArraySerializer
{
DataArray = TotalMTOfZSecondMoment,
Name = "TotalMTOfZSecondMoment",
FileTag = "_TotalMTOfZ_2",
WriteData = binaryWriter =>
{
if (!TallySecondMoment || TotalMTOfZSecondMoment == null)
{
return;
}
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < Z.Count - 1; j++)
{
binaryWriter.Write(TotalMTOfZSecondMoment[i, j].Real);
binaryWriter.Write(TotalMTOfZSecondMoment[i, j].Imaginary);
}
}
},
ReadData = binaryReader =>
{
if (!TallySecondMoment || TotalMTOfZSecondMoment == null)
{
return;
}
TotalMTOfZSecondMoment = new Complex[Fx.Count, Z.Count - 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < Z.Count - 1; j++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
TotalMTOfZSecondMoment[i, j] = new Complex(real, imag);
}
}
},
},
new BinaryArraySerializer
{
DataArray = DynamicMTOfZSecondMoment,
Name = "DynamicMTOfZSecondMoment",
FileTag = "_DynamicMTOfZ_2",
WriteData = binaryWriter =>
{
if (!TallySecondMoment || DynamicMTOfZSecondMoment == null)
{
return;
}
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < Z.Count - 1; j++)
{
binaryWriter.Write(DynamicMTOfZSecondMoment[i, j].Real);
binaryWriter.Write(DynamicMTOfZSecondMoment[i, j].Imaginary);
}
}
},
ReadData = binaryReader =>
{
if (!TallySecondMoment || DynamicMTOfZSecondMoment == null)
{
return;
}
DynamicMTOfZSecondMoment = new Complex[Fx.Count, Z.Count - 1];
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < Z.Count - 1; j++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
DynamicMTOfZSecondMoment[i, j] = new Complex(real, imag);
}
}
},
},
new BinaryArraySerializer
{
DataArray = SecondMoment,
Name = "SecondMoment",
FileTag = "_2",
WriteData = binaryWriter =>
{
if (!TallySecondMoment || SecondMoment == null)
{
return;
}
for (int i = 0; i < Fx.Count; i++)
{
for (int j = 0; j < MTBins.Count - 1; j++)
{
binaryWriter.Write(SecondMoment[i, j].Real);
binaryWriter.Write(SecondMoment[i, j].Imaginary);
}
}
},
ReadData = binaryReader =>
{
if (!TallySecondMoment || SecondMoment == null)
{
return;
}
SecondMoment = new Complex[Fx.Count, MTBins.Count - 1];
for (int i = 0; i < Fx.Count - 1; i++)
{
for (int j = 0; j < MTBins.Count - 1; j++)
{
var real = binaryReader.ReadDouble();
var imag = binaryReader.ReadDouble();
SecondMoment[i, j] = new Complex(real, imag);
}
}
},
},
});
}
public override void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, int rowsA, int columnsA, Complex[] b, int rowsB, int columnsB, Complex beta, Complex[] c)
{
if (a == null)
{
throw new ArgumentNullException(nameof(a));
}
if (b == null)
{
throw new ArgumentNullException(nameof(b));
}
if (c == null)
{
throw new ArgumentNullException(nameof(c));
}
var m = transposeA == Transpose.DontTranspose ? rowsA : columnsA;
var n = transposeB == Transpose.DontTranspose ? columnsB : rowsB;
var k = transposeA == Transpose.DontTranspose ? columnsA : rowsA;
var l = transposeB == Transpose.DontTranspose ? rowsB : columnsB;
if (c.Length != m * n)
{
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
if (k != l)
{
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
}
SafeNativeMethods.z_matrix_multiply(transposeA, transposeB, m, n, k, alpha, a, b, beta, c);
}
private void btnDoOneMeasurement_Click(object sender, EventArgs e)
{
Complex imp = Program.a.GetMeasurement();
this.label148.Text = AgilentHelper.ImpedanceToString(imp, false);
}
/// <summary>
/// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
/// </summary>
/// <param name="input">The right hand side <see cref="Matrix{T}"/>, <b>B</b>.</param>
/// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>X</b>.</param>
public override void Solve(Matrix <Complex> input, Matrix <Complex> result)
{
// Check for proper arguments.
if (input == null)
{
throw new ArgumentNullException("input");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
// The solution X should have the same number of columns as B
if (input.ColumnCount != result.ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension);
}
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
if (MatrixQ.RowCount != input.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension);
}
// The solution X row dimension is equal to the column dimension of A
if (MatrixQ.ColumnCount != result.RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension);
}
var inputCopy = input.Clone();
// Compute Y = transpose(Q)*B
var column = new Complex[MatrixQ.RowCount];
for (var j = 0; j < input.ColumnCount; j++)
{
for (var k = 0; k < MatrixQ.RowCount; k++)
{
column[k] = inputCopy.At(k, j);
}
for (var i = 0; i < MatrixQ.ColumnCount; i++)
{
var s = Complex.Zero;
for (var k = 0; k < MatrixQ.RowCount; k++)
{
s += MatrixQ.At(k, i).Conjugate() * column[k];
}
inputCopy.At(i, j, s);
}
}
// Solve R*X = Y;
for (var k = MatrixQ.ColumnCount - 1; k >= 0; k--)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(k, j, inputCopy.At(k, j) / MatrixR.At(k, k));
}
for (var i = 0; i < k; i++)
{
for (var j = 0; j < input.ColumnCount; j++)
{
inputCopy.At(i, j, inputCopy.At(i, j) - (inputCopy.At(k, j) * MatrixR.At(i, k)));
}
}
}
for (var i = 0; i < MatrixR.ColumnCount; i++)
{
for (var j = 0; j < input.ColumnCount; j++)
{
result.At(i, j, inputCopy.At(i, j));
}
}
}
public static Complex Round(Complex value) => new Complex(Math.Round(value.Real), Math.Round(value.Imaginary));
/// <summary>
/// method to tally to detector
/// </summary>
/// <param name="photon">photon data needed to tally</param>
public void Tally(Photon photon)
{
if (!IsWithinDetectorAperture(photon))
{
return;
}
// calculate the radial bin to attribute the deposition
var tissueMT = new double[2]; // 2 is for [static, dynamic] tally separation
bool talliedMT = false;
double totalMT = 0;
var totalMTOfZForOnePhoton = new Complex[Fx.Count, Z.Count - 1];
var dynamicMTOfZForOnePhoton = new Complex[Fx.Count, Z.Count - 1];
var fxArray = Fx.AsEnumerable().ToArray();
var x = photon.DP.Position.X; // use final exiting x position
var sinNegativeTwoPiFX = fxArray.Select(fx => Math.Sin(-2 * Math.PI * fx * x)).ToArray();
var cosNegativeTwoPiFX = fxArray.Select(fx => Math.Cos(-2 * Math.PI * fx * x)).ToArray();
// go through photon history and claculate momentum transfer
// assumes that no MT tallied at pseudo-collisions (reflections and refractions)
// this algorithm needs to look ahead to angle of next DP, but needs info from previous to determine whether real or pseudo-collision
PhotonDataPoint previousDP = photon.History.HistoryData.First();
PhotonDataPoint currentDP = photon.History.HistoryData.Skip(1).Take(1).First();
foreach (PhotonDataPoint nextDP in photon.History.HistoryData.Skip(2))
{
if (previousDP.Weight != currentDP.Weight) // only for true collision points
{
var csr = _tissue.GetRegionIndex(currentDP.Position); // get current region index
// get z bin of current position
var iz = DetectorBinning.WhichBin(currentDP.Position.Z, Z.Count - 1, Z.Delta, Z.Start);
// get angle between current and next
double cosineBetweenTrajectories = Direction.GetDotProduct(currentDP.Direction, nextDP.Direction);
var momentumTransfer = 1 - cosineBetweenTrajectories;
totalMT += momentumTransfer;
for (int ifx = 0; ifx < Fx.Count; ifx++)
{
var deltaWeight = photon.DP.Weight * cosNegativeTwoPiFX[ifx] +
Complex.ImaginaryOne * sinNegativeTwoPiFX[ifx];
TotalMTOfZ[ifx, iz] += deltaWeight * momentumTransfer;
totalMTOfZForOnePhoton[ifx, iz] += deltaWeight * momentumTransfer;
}
if (_rng.NextDouble() < _bloodVolumeFraction[csr]) // hit blood
{
tissueMT[1] += momentumTransfer;
for (int ifx = 0; ifx < Fx.Count; ifx++)
{
var deltaWeight = photon.DP.Weight * cosNegativeTwoPiFX[ifx] +
Complex.ImaginaryOne * sinNegativeTwoPiFX[ifx];
DynamicMTOfZ[ifx, iz] += deltaWeight * momentumTransfer;
dynamicMTOfZForOnePhoton[ifx, iz] += deltaWeight * momentumTransfer;
}
SubregionCollisions[csr, 1] += 1; // add to dynamic collision count
}
else // index 0 captures static events
{
tissueMT[0] += momentumTransfer;
SubregionCollisions[csr, 0] += 1; // add to static collision count
}
talliedMT = true;
}
previousDP = currentDP;
currentDP = nextDP;
}
if (totalMT > 0.0) // only tally if momentum transfer accumulated
{
var imt = DetectorBinning.WhichBin(totalMT, MTBins.Count - 1, MTBins.Delta, MTBins.Start);
for (int ifx = 0; ifx < Fx.Count; ifx++)
{
var deltaWeight = photon.DP.Weight * cosNegativeTwoPiFX[ifx] +
Complex.ImaginaryOne * sinNegativeTwoPiFX[ifx];
Mean[ifx, imt] += deltaWeight;
if (TallySecondMoment)
{
SecondMoment[ifx, imt] += deltaWeight * deltaWeight;
for (int i = 0; i < Fx.Count - 1; i++)
{
for (int j = 0; j < Z.Count - 1; j++)
{
TotalMTOfZSecondMoment[i, j] +=
totalMTOfZForOnePhoton[i, j] * totalMTOfZForOnePhoton[i, j];
DynamicMTOfZSecondMoment[i, j] +=
dynamicMTOfZForOnePhoton[i, j] * dynamicMTOfZForOnePhoton[i, j];
}
}
}
if (talliedMT)
{
TallyCount++;
}
// tally DYNAMIC fractional MT in each subregion
int ifrac;
for (int isr = 0; isr < NumSubregions; isr++)
{
// add 1 to ifrac to offset bin 0 added for =0 only tallies
ifrac = DetectorBinning.WhichBin(tissueMT[1] / totalMT,
FractionalMTBins.Count - 1, FractionalMTBins.Delta, FractionalMTBins.Start) + 1;
// put identically 0 fractional MT into separate bin at index 0
if (tissueMT[1] / totalMT == 0.0)
{
ifrac = 0;
}
// put identically 1 fractional MT into separate bin at index Count+1 -1
if (tissueMT[1] / totalMT == 1.0)
{
ifrac = FractionalMTBins.Count;
}
FractionalMT[ifx, imt, ifrac] += deltaWeight;
}
}
}
}
public static Complex Ceiling(Complex value) => new Complex(Math.Ceiling(value.Real), Math.Ceiling(value.Imaginary));
public static Complex Sign(Complex value)
{
var arg = Math.Atan2(value.Imaginary, value.Real);
return(new Complex(Math.Cos(arg), Math.Sin(arg)));
}
public static Complex Min(Complex a, Complex b) => IsGreaterThan(a, b) ? b : a;
public static Complex Floor(Complex value) => new Complex(Math.Floor(value.Real), Math.Floor(value.Imaginary));
public static Boolean IsGreaterThan(Complex a, Complex b) => Complex.Abs(a) > Complex.Abs(b);
public static Complex Max(Complex a, Complex b) => IsGreaterThan(a, b) ? a : b;
public static Complex Acsch(Complex value) => Complex.Log(1.0 / value + Complex.Sqrt(1.0 / (value * value) + 1.0));
public static Boolean IsLessThan(Complex a, Complex b) => Complex.Abs(a) < Complex.Abs(b);
public static Complex Csch(Complex value) => 2.0 / (Complex.Exp(value) - Complex.Exp(-value));
public static Complex Log2(Complex value) => Complex.Log(value, 2.0);