I was trying to make a matlab code to store arrays in it. I want to create a matrix of 5 rows and 3900 columns to store five different arrays in it.
Each time I run my matlab code it should store the array in the first empty row and next time I run the code the matrix should store the new array in the second empty row and so on until all five rows are occupied by five different arrays.
here is my code :
matrix = zeros(5,3900);
k=1;
d=5;
if k<=d
matrix(k,:) = Array;
k=k+1;
end
this code does not give my what I want
even this one does not do the correct job as I described above
matrix = zeros(5,3900);
k=1;
if (k<=5)
matrix(k,:) = Array;
k=k+1;
end
and this
matrix = zeros(5,3900);
for k=1:5
matrix(k,:) = Array;
end
What should I do to store one array of size 1*3900 in only one row in the first time and in the next run I want that the another array stores in the second row and so on until row number 5?
thank you all
From my understanding you want to run the code several times, but each time the array is different, which is filling up the matrix.
In your example you're overwriting matrix and k each time you run the code and that's (if I understand you right) is preventing from correct execution. What you could do is something like:
initialize before you run the first time your code: matrix = zeros(5,3900);and k=1;
Run afterwards your first code without matrix = zeros(5,3900);
k=1;
In this case matrix and k should increment as you wish it.
Edit:
The first code, which you posted, will do the following (each time you run it):
create an matrix of size [3,3900] with all 0 -entries. if the variable matrix already exists, it will be completely overwritten
same for k and d but with 1 and 5, respectively
check if k<=d: this condition is always true because k = 1 and d = 5
assign on the first row of matrix the values of array(first row because k = 1)
add 1 to k
So you see the statement #5 has no influence because each time you run your code k and matrix are overwritten.
So what you have to do is to NOT set matrix = zeros(5,3900);
k=1; at the begin of your code. In this way matrix and k remain the same. But you have to take care to initialize at k and matrix before you run the first time your code (if not Matlab doesn't know what k is)
Is this clearer now?
Micha
Related
I am trying to find a solution in a C programming
I have a 2d array, but i dont know its size
I can only access the array with a array view of [11][11]
The main idea is to find the peak of a mountain (max element)
So basically my 2d array is a map where each index is a float number, corresponding to the height of the mountain
I know i am out of the map when my float number is -1
That is what i was thinking to do, but i cant put it onto a code in a proper way
My solution is based on brute force approach
my basic idea was getting one 2d array formed by myview
what would give me a [11][11] array
then get a max value on that [11][11] array and store it.
next step i would generate another myview array using a loop.
i would apply same process here, to get a max value on that new array
then i would compare myfirst Max value with that second Max value
the value who have the biggest value would be stored on my max variable, with the location as well (point x and point y).
then i would run a loop again to create another myview array, and so on.
My plan to run on all possible [11][11]arrays is:
starting from running a loop for all the columns, but always keeping the rows 1-11
i know there is no more columns when all the values inside of my array [11][11] are -1.0
so when i find that array i would jump for next section of rows (12-23) for example
and again run for all columns.
i also could set a max value per set of a row (so at set of rows 1-11 the max value (peak) is 197.15 , then at set of rows 12-23 the max value (peak) is 397.15, for example)
i know will not be more rows when in my first set of columns i get the values inside of my array [11][11] -1.0000
so i would just need to get my biggest value on all set of rows, then i would get my solution.
You mean you have a two-dimensional array with two lines of eleven elements each, as you would get if you ran int array[11][11];? Then you can have two nested loops, one for (int i = 0; i < 2; i++) and for (int j = 0; j < 11; j++) nested inside each other to loop over the individual elements of the two lines. You have a buffer variable that holds the maximum so far. In your loop you compare each element you're looping over against the buffer variable, and the new element becomes the new buffer variable if it's bigger than the existing one:
void main(void) {
int array[11][11];
int buffer = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; 11 < 2; j++) {
if (array[i][j] > buffer) {buffer = array[i][j];}
}
}
}
I want to create 3d arrays that are functions of 2d arrays and apply matrix operations on each of the 2D arrays. Right now I am using for loop to create a series of 2d arrays, as in the code below:
for i=1:50
F = [1 0 0; 0 i/10 0; 0 0 1];
B=F*F';
end
Is there a way to do this without the for loop? I tried things such as:
F(2,2) = 0:0.1:5;
and:
f=1:0.1:5;
F=[1 0 0; 0 f 0; 0 0 1];
to create them without the loop, but both give errors of dimension inconsistency.
I also want to perform matrix operations on F in my code, such as
B=F*F';
and want to plot certain components of F as a function of something else. Is it possible to completely eliminate the for loop in such a case?
If I understand what you want correctly, you want 50 2D matrices stacked into a 3D matrix where the middle entry varies from 1/10 to 50/10 = 5 in steps of 1/10. You almost have it correct. What you would need to do is first create a 3D matrix stack, then assign a 3D vector to the middle entry.
Something like this would do:
N = 50;
F = repmat(eye(3,3), [1 1 N]);
F(2,2,:) = (1:N)/10; %// This is 1/10 to 5 in steps of 1/10... or 0.1:0.1:5
First pre-allocate a matrix F that is the identity matrix for all slices, then replace the middle row and middle column of each slice with i/10 for i = 1, 2, ..., 50.
Therefore, to get the ith slice, simply do:
out = F(:,:,i);
Minor Note
I noticed that what you want to do in the end is a matrix multiplication of the 3D matrices. That operation is not defined in MATLAB nor anywhere in a linear algebra context. If you want to multiply each 2D slice independently, you'd be better off using a for loop. Doing this vectorized with native operations isn't supported in this context.
To do it in a loop, you'd do something like this for each slice:
B = zeros(size(F));
for ii = 1 : size(B,3)
B(:,:,ii) = F(:,:,ii)*F(:,:,ii).';
end
... however, examining the properties of your matrix, the only thing that varies is the middle entry. If you perform a matrix multiplication, all of the entries per slice are going to be the same... except for the middle, where the entry is simply itself squared. It doesn't matter if you multiple one slice by the transpose of the other. The transpose of the identity is still the identity.
If your matrices are going to be like this, you can just perform an element-wise multiplication with itself:
B = F.*F;
This will not work if F is anything else but what you have above.
Creating the matrix would be easy:
N = 50;
S = cell(1,N);
S(:) = {eye(3,3)};
F = cat(3, S{:});
F(2,2,:) = (1:N)/10;
Another (faster) way would be:
N = 50;
F = zeros(3,3,N);
F(1,1,:) = 1;
F(2,2,:) = (1:N)/10;
F(3,3,:) = 1;
You then can get the 3rd matrix (for example) by:
F(:,:,3)
I won't bother you with all the dry details of what is the assignment and the problem I'm trying to solve, I'll cut right to the chase.
I need to fill a matrix with data. the matrix is square and everything is zero except the first 2 diagonals (meaning M[i][i] for i between 0 and n-1 and M[i][i+1] for i between 0 and n-2 are already filled)
We want to fill the matrix using this a bit complex formula.
M[i][j]=max(a+min(M[i+2][j],M[i+1][j-1]) , b+min(M[i+1][j-1],M[i][j-2]))
The result is an upper triangular matrix. You can see from the above formula that to compute the k'th diagonal, we need the k-2 diagonal. And I said the first 2 are given.
I wrote a code to fill the matrix and it is working as intended.
Here is my problem:
Since it is an upper triangular matrix, the lower half is all zero. so there is no point in wasting memory and saving it. So I thought to myself instead of allocating an n by n matrix, I will allocate n rows, and to the first row ill allocate n spaces, to the second n-1, to the third n-2 and so on...
But since we changed the dimensions of the matrix, the formula I wrote above to compute M[i][j] is different now. In my opinion, we moves all the values in the i'th row, i columns to the left. in row 0 nothing changed. in row 1, we pulled all the values 1 column to the left, etc. So if I understand correctly:
M[i][j]=M'[i][j-i]
Where M' is our new matrix. And so plugging that in the formula above:
M'[i][j]=max(a+min(M'[i+2][j-i],M'[i+1][j-1-i]) , b+min(M'[i+1][j-1-i],M'[i][j-2-i]))
However now the program to fill the matrix is not working correctly. It is filling the matrix with garbage.
Here is the code to fill the matrix:
void fill_matrix() //fills the matrix with data of optimal path, we use memoization rather than recursion, so this step is necessary.
{ //first step is to allocate the matrix. we can assume right_index==size-1 since this is the first thing we do after generating the array
int i,j;
optimum_matrix=(int**)malloc((right_index+1)*sizeof(int**));
for(j=0;j<=right_index;j++)
optimum_matrix[j]=(int*)malloc((right_index+1-j)*sizeof(int*)); //matrix allocated. upper triangular matrix. no need to allocate n^2 spaces. //to fix indices, M[i][j]=M'[i][j-i+1]. subtract i and add 1 to each column, since we moved each entry in row i, i-1 columns back.
for(i=0;i<=right_index;i++) //first diagonal
optimum_matrix[i][0]=data_array[i];
for(i=0;i<right_index;i++) //second diagonal
optimum_matrix[i][1]=get_max(data_array[i],data_array[i+1]);
for(i=0;i<=right_index;i++)
{
for(j=2;j<=right_index-i;j++)
optimum_matrix[i][j]=get_max(data_array[i]+get_min(optimum_matrix[i+2][j-i],optimum_matrix[i+1][j-i-1]),data_array[j]+get_min(optimum_matrix[i+1][j-i-1],optimum_matrix[i][j-i-2])); //here is the problem
}
}
And this is the code to print the matrix
void print_matrix()
{
int i,j,k;
for(i=0;i<=right_index;i++)
{
for(k=0;k<i;k++)
printf("0 ");
for(j=0;j<=right_index-i;j++)
printf("%d ",optimum_matrix[i][j]);
printf("\n");
}
}
Even on the first iteration of filling the third diagonal, when it enters the for loop where it says "here is the problem", if i type printf("%d",optimum_matrix[i+2][j-i]); it will print garbage. And I don't understand why since the formula agrees.
Would appreciate help. Thank you.
optimum_matrix=(int**)malloc((right_index+1)*sizeof(int**));
That isn't the right way to allocate a double array. It's allocating only one dimension of the double array. It's hard for me to follow your logic on how big you want each row and column to be. So below may not be the exact right dimensions you want. But hopefully it does illustrate how to more correctly allocate the double array.
int **optimum_matrix = malloc((right_index+1)*sizeof(int*));
for (i = 0; i < (right_index+1); i++) {
optium_matrix[i] = malloc((right_index+1)*sizeof(int));
}
BTW, I left out the check of the malloc return value for brevity. And your original code also doesn't check the return value of malloc. That should always be done.
I have problem that really confuses me a lot. I want to have a sparse matrix stored in 3 arrays and perform matrix/vector multiplication. Matrix and vectorB are red from a file. That's the background. The problem is in unwanted changing the value of an integer array element being an "argument" of the double array. Here is what I am doing:
int row[ELEMENTS_NO] = {0};
int col[ELEMENTS_NO] = {0};
double values[ELEMENTS_NO] = {0.0};
double vectorB[M_SIZE] = {0.0};
double res[M_SIZE]={0.0};
...reading row,col,values, from the file...
printf("\n row[0]:%d, col[0]:%d",row[0],col[0]);
for (k = 0; k < ELEMENTS_NO; k++) {
res[row[k]] = res[row[k]] + values[k]*vectorB[col[k]];
}
printf("\n\n\n row[0]:%d, col[0]:%d",row[0],col[0]);
the output of the first print is correct:
row[0]:1, col[0]:1
while the second print gives me following output:
row[0]:1352932126, col[0]:1
Why the value of col array changed after executing for loop? How to solve my problem and remain row and col elements unchanged?
Thank you for any useful information!
Check the value of row[k] and make sure it's between 0 and ELEMENTS_NO
My best guess is that one of the elements of row is negative, thus res[row[k]] would be negative.
Try running the program using valgrind, this will tell you when you have out of bounds problems for arrays.
You are indexing res[] by a value from the row array. The first one is over 1 billion, so you are changing the (more than) billionth element of res[] which I suspect is beyond the end of the array. Then anything can happen, including overwriting other variables.
I'm stuck here. I've got a matrix of size NxN stored in a double array. Then I want to delete a given column, lets say the first column. So I created a new double array of size NxN-1 and copy the values from the first matrix to the second one, except the 1st column of course. But then I want to set the first array to be the second array. I am blanking here.
double matrix[N][N]
//fill up the matrix code here...
// remove first column of array
double newMatrix[N][N-1];
for(i = 0; i < N; i++){
for(j = 1; j < N; j++){
newMatrix[i][j-1] = matrix[i][j];
}
}
matrix = newMatrix; // how do I set this correctly? Do I need to realloc the first array?
You cannot assign arrays in C, which I assume that your compiler tells you. To do such dynamic memory management, you will need to use pointers instead of arrays. I suggest you read up on how malloc() and free() work so that you can do what you want.
Edit:
Another solution comes to mind if you are only removing columns (or rows): keep track of the number of rows and columns used in the array. Then you can remove a row or column within the original array without creating a copy first. Just move the data past the delete column (or row) to the left (or up) then decrement your size counters. (I hope this make sense. If not let me know and I'll elaborate.)
like Code-guru said malloc() and free() should help alot, but if u simply wanted to delete the last column the you wouldn't need two arrays:
double matrix[2][3] = {1,2,3,4,5,6}; //declaring a 2 by 3 matrix
for (i=0;i<2;i++) //rows
{
for (j=0;j<3-1;j++) //columns - 1
{
printf("%.1f ",matrix[i][j]); //I chose to display matrix...
}
printf("\n");
}
Instead of accessing elements from array[i][j], one might opt to access elements from array + stride_x[x] + stride_y[y]; where array is originally introduced as double matrix[N*N]; or double *matrix = malloc(sizeof(double)*N*N);.
The stride_y[x] would originally contain offsets of columns for all rows: 0 1 2 3 4 ... N-1 and stride_y[y] would contain similar offsets multiplied with original row width 0 N 2*N 3*N..
From these 1-D arrays one can more effortlessly delete or exchange complete rows and columns, which may come handy in eg. recursive implementation of determinant calculation / Gauss Jordan elimination.