Double [] test

David Smith

I am struggling, I am trying to pass in double [] array and added to my ArrayDictionary , can someone assist me.

enum ArrayType
{
Array1,
Array2,
Array3

}

public Dictionary> ArrayDictionary { get; set; }

public void ConstructArray(double[] array1, double[] array2, double[] array3)
{
foreach (ArrayType arrayItem in Enum.GetValues(typeof(ArrayType)))
{
ArrayDictionary.Add(arrayItem .ToString(), new List());

switch (opticalArrayItem)
{
case ArrayType.Array1:

foreach (double arrayItem in array1)
{
// Add to ArrayDictionary

}
break;

case ArrayType.Array2:
foreach (double arrayItem in array1)
{
// Add to ArrayDictionary b

}
break;

case ArrayType.Array3:
foreach (double arrayItem in array1)
{
// Add to ArrayDictionary

}

break;
}
}
}

21 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
There are 401 values in the series 1.30, 1.31 .... , 5.30

So, if 'i' is running from 0 to (n - 1) for each GivenArray, there will be (401 * n) elements in each NewArray. The following is off the top of my head and so is untested:

int len = GivenArray1.Length;
int ix = 0;
double temp = 0.0;
double[] NewArray1 = new double[401 * len];
double[] NewArray2 = new double[401 * len];
double[] NewArray3 = new double[401 * len];

for(int i = 0; i < len; i++)
{
for(int w = 130; w <= 530; w++)
{
ix = 401 * i + w - 130;

temp = GivenArray1[i] * GivenArray2[i] * GivenArray3[i] * (GivenArray2[i] - GivenArray2[i] * Math.Pow(w/100.0, 5));
NewArray1[ix] = temp + GivenArray2[i];
NewArray2[ix] = temp + NewArray1[ix];
NewArray3[ix] = temp + NewArray2[ix];
}
}

double total123 = 0.0, total1 = 0.0;
for(int i = 0; i < NewArray1.Length; i++) total123 += NewArray1[i] * NewArray2[i] * NewArray3[i];
for(int i = 0; i < NewArray1.Length; i++) total1 += NewArray1[i];
double finalOutput = total123/total1;
David Smith14y ago
thanks vuples you have truly been a help to me. thanks, at least i can say i learn alot about link and the first time really playing around with an array of double like i am doing now. this was an interesting project and fun.
David Smith14y ago
Sorry about that, copy paste error

NewArray1 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray3[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + GivenArray2[]   );

NewArray2 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray3[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + NewArray1 []);

NewArray3 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray3[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + NewArray3 [] );
Vulpes14y ago
Can you check those formulae as GivenArray3 doesn't appear in them and, presumably, should do?
David Smith14y ago
Its iterating by 10 nano meters. I guess i give you the whole picture, i was trying to do piece by piece, basically all array are calculater by 10 nano meters that I am given from 1.30 to 5.30, Example : 1.30, 1.31, 1.33, 1.34, 1.35 ........to 5.28, 5.29, 5.30 etc........

I cant go into detail but , I am going to use 3 to 4 arrays only like we have been. We are on track, just got to re think the logic to get to the final output.

I am still using the

enum ArrayType
{
Array1,
Array2,
Array3

}

Dictionary>> ArrayTypeDictionary { get; set; }

double[] GivenArray1{ get; set; }

double[] GivenArray2{ get; set; }

double[] GivenArray3{ get; set; }

1. Construct all ways from 1.30 to 5.30 by 10 nano meters by given formula below

    Note: wavelength is the values changing from 1.30 to 5.30 by 10 nano meters

NewArray1 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray2[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + GivenArray2[]   );

NewArray2 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray2[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + NewArray1 []);

NewArray3 [] = ((GivenArray1[] * GivenArray2[]   * GivenArray2[] ( GivenArray2[]   - GivenArray2[] (Math.Pow(
                        waveLength ,5) )) + NewArray3 [] );

2. After constructing each given array , Each array will construct another output Array from 1.30 to 5.30 by 10 nano meters by formula given.

3. There will be a total of 7 arrays, need to get to the final single output double value.

double finalOutput = (Summation (NewArray1 [] * NewArray2 [] * NewArray3 [])) / (Summation (NewArray1 []))
Vulpes14y ago
If the wavelength is also iterating by 1 viz: 1.30, 2.30, 3.30, 4.30, 5.30 then it's always going to be 1.30 more than the integer index i which is iterating from 0 to 4.

So that would give:

double[] Output2 = new double[Array1.Length];
double[] NewArray = new double[Array1.Length];

for(int i = 0; i < Array1.Length; i++)
{
Output2[i] = Array1[i] * Array2[i] * Array3[i] * (Array2[i] - Array1[i]) + Array1[i];

NewArray[] = Array1[i] + Array2[i] + Math.Pow(i + 1.3, 5) - Output2[i];
}
David Smith14y ago
Ok now i have came across a situation, basically my my wavelength limit in the array is suppose to be from 1.30 to 5.30 which are doubles but we are indexing by int, how to fix this situation. The wavelength value can't be the [i], it has to be a specfic value iterating from 1.30 to 5.30. We are almost there, getting to the end.

double[] Output2 = new double[Array1.Length];
for(int i = 0; i < Array1.Length; i++)
       {
Output2[i] = Array1[i] * Array2[i] * Array3[i] * (Array2[i] - Array1[i]) + Array1[i];

          NewArray[] = (Array1[i] + Array2[i]) + (Math.Pow(WaveLength, 5)) - Output2[i] )
       }
Vulpes14y ago
OK, here's the code for that.

I've also included an alternative approach using LINQ which is closer to the traditional approach and therefore more efficient than using Zip:

double[] Array1 = t.ArrayDictionary[ArrayType.Array1.ToString()][0];
double[] Array2 = t.ArrayDictionary[ArrayType.Array2.ToString()][0];
double[] Array3 = t.ArrayDictionary[ArrayType.Array3.ToString()][0];

// using LINQ

double[] Output = Array1.Zip(Array2, (a1, a2) => a1 * a2 * (a2 - a1)).ToArray()
.Zip(Array3, (a12, a3) => a12 * a3).ToArray()
.Zip(Array1, (a123, a1) => a123 + a1).ToArray();

foreach(double d in Output) Console.WriteLine(d);

// using traditional approach

double[] Output2 = new double[Array1.Length];
for(int i = 0; i < Array1.Length; i++)
Output2[i] = Array1[i] * Array2[i] * Array3[i] * (Array2[i] - Array1[i]) + Array1[i];

foreach(double d in Output2) Console.WriteLine(d);

// using alternative LINQ approach

double[] Output3 = Enumerable.Range(0, Array1.Length).Select(i => Array1[i] * Array2[i] * Array3[i] *(Array2[i] - Array1[i]) + Array1[i]).ToArray();

foreach(double d in Output3) Console.WriteLine(d);
David Smith14y ago
I had the formula wrong, im glad you caught that. thanks my eyes getting weak.

OutPut[i]=(( ArrayDictionary [Array1][i] * ArrayDictionary [Array2][i] * ArrayDictionary [Array3][i]

                 * (ArrayDictionary Array2][i] - ArrayDictionary [Array1][i]))

                 + ArrayDictionary [Array1][i]);
Vulpes14y ago
Are you sure that there isn't a plus operator where I've marked?

Output[] =( (Array1[] * Array2[] * Array3[] + ( Array1[] * Array2[] ) )+ Array1[] )
David Smith14y ago
show both ways, the traditional way look cleaner, linq is cool , show both, i getting a better at the linq day by day
David Smith14y ago
This is the true equation how to Zip this up correctly using linq

Output[] =( (Array1[] * Array2[] * Array3[] ( Array1[] * Array2[] ) )+ Array1[] )
David Smith14y ago
sorry i didnt ready clearly sorry about that vuples, you did right. brb
David Smith14y ago
Sorry for the confusion, im try to store Array1, Array2, and Array3 in to the output Array. So this time it will not be an a single output, the out put will be an array itself. I am trying to add Array1, Array2, and Array3 together. Review equation below. Look at the array brackets.

Output[] =( Array1[] * Array2[] * Array3[])

Output [] will not be a single bracket, it will be the array output of ( Array1[] * Array2[] * Array3[])
Vulpes14y ago
It can be done in LINQ but not very elegantly or efficiently. Frankly, I'd use the traditional method.

Here's the code for both:

// using LINQ

double[] Output = Array1.Zip(Array2, (a1, a2) => a1 * a2).ToArray()
.Zip(Array3, (a12, a3) => a12 * a3).ToArray();

foreach(double d in Output) Console.WriteLine(d);

// using traditional approach

double[] Output2 = new double[Array1.Length];
for(int i = 0; i < Array1.Length; i++)
Output2[i] = Array1[i] * Array2[i] * Array3[i];

foreach(double d in Output2) Console.WriteLine(d);

The output in either case will be :

28
80
162
David Smith14y ago
ok we almost there,

now that we have all the arrays i need to multiply all the array into one array, how to do this using linq, review below.

Output[] = Array1[] * Array2[] * Array3[]
Vulpes14y ago
It won't compile if you do that.

You'll be informed that List.Add has some invalid arguments - argument 1 cannot convert from double to double[].

If it's any help to you, here's a little program I did to test my own code and make sure the Dictionary could be iterated subsequently:

using System;
using System.Collections.Generic;

enum ArrayType
{
Array1,
Array2,
Array3

}

class Test
{

static void Main()
{
Test t = new Test();
var array1 = new double[]{1, 2, 3};
var array2 = new double[]{4, 5, 6};
var array3 = new double[]{7, 8, 9};
t.ConstructArray(array1, array2, array3);

foreach(string arrayItem in t.ArrayDictionary.Keys)
{
foreach(double[] da in t.ArrayDictionary[arrayItem])
foreach(double d in da)
Console.WriteLine(d);
}

Console.ReadKey();
}

public Dictionary> ArrayDictionary { get; set; }

public void ConstructArray(double[] array1, double[] array2, double[] array3)
{
ArrayDictionary = new Dictionary>(); // if not instantiated elsewhere

foreach (ArrayType arrayItem in Enum.GetValues(typeof(ArrayType)))
{
ArrayDictionary.Add(arrayItem.ToString(), new List());
switch (arrayItem)
{
case ArrayType.Array1:

ArrayDictionary[arrayItem.ToString()].Add(array1);
break;

case ArrayType.Array2:

ArrayDictionary[arrayItem.ToString()].Add(array2);
break;

case ArrayType.Array3:

ArrayDictionary[arrayItem.ToString()].Add(array3);
break;
}
}
}
}
David Smith14y ago
I had to add each foreach to each switch case to get each item out of the passed double array

public Dictionary> ArrayDictionary { get; set; }

public void ConstructArray(double[] array1, double[] array2, double[] array3)
{
     ArrayDictionary = new Dictionary>(); // if not instantiated elsewhere

     foreach (ArrayType arrayItem in Enum.GetValues(typeof(ArrayType)))
     {
        ArrayDictionary.Add(arrayItem.ToString(), new List());
        switch (arrayItem)
        {
          case ArrayType.Array1:

            foreach( var item in array1)
            {
               ArrayDictionary[arrayItem.ToString()].Add(item );
            }
            break;

          case ArrayType.Array2:

             foreach( var item in array2)
            {
               ArrayDictionary[arrayItem.ToString()].Add(item );
            }
            break;

          case ArrayType.Array3:

             foreach( var item in array3)
            {
               ArrayDictionary[arrayItem.ToString()].Add(item );
            }
            break;

        }
     }
}
Vulpes14y ago
That's right.

Because the Dictionary's value is a List of double arrays, you can simply add a double array to the list for a given key.
David Smith14y ago
Question, so are you saying there is no reason to do a foreach or iteration in each switch case?
Vulpes14y ago
I'm assuming that 'opticalArrayItem' should just be 'arrayItem' as the code would make little sense otherwise:

public Dictionary> ArrayDictionary { get; set; }

public void ConstructArray(double[] array1, double[] array2, double[] array3)
{
ArrayDictionary = new Dictionary>(); // if not instantiated elsewhere

foreach (ArrayType arrayItem in Enum.GetValues(typeof(ArrayType)))
{
ArrayDictionary.Add(arrayItem.ToString(), new List());
switch (arrayItem)
{
case ArrayType.Array1:

ArrayDictionary[arrayItem.ToString()].Add(array1);
break;

case ArrayType.Array2:

ArrayDictionary[arrayItem.ToString()].Add(array2);
break;

case ArrayType.Array3:

ArrayDictionary[arrayItem.ToString()].Add(array3);
break;

}
}
}