how to reverse values of every other column in a big matrix wave ?

Here is a quick solution based on 200 rows, i.e. p goes from 0 to 199.

Duplicate oldwave, newwave

NewWave = mod(q,2)? oldwave[199-p][q] : oldwave[p][q]

Logic: checks to see if column is odd, modulus=1. and then reverses the row assignment.  If even, modulus = 0, then just copies.

Andy

Here is a less-quick solution:

this is cool thanks, what does "?" mark in command mean?

Really cool , thanks a lot

From manual

? :
? : is the conditional operator, which is a shorthand form of an if-else-endif statement. It is of the form: 
<expression> ? <TRUE> : <FALSE>  
When expression is nonzero, it evaluates the TRUE part, otherwise it evaluates the FALSE part. The ":" character in the conditional operator must always be separated with spaces from the two adjacent operands. The operands must be numeric; for strings, you must use the SelectString function.
See Operators for a list of all operators in order of precedence.
Examples
Replace zero values with blanks:
Wave w = wave0
w = w[p]==0 ? NaN : w[p]

Andy

Here is a more-quick solution:

Wow, Steve- you're getting to be almost as creative with MatrixOP as AG is!

Thanks, John. I am but Grasshopper at the feet of the Master :)

Sometimes the effort of Parsing MatrixOP pays off. For the (200 row, 298 col) case cited above, the point-index method gives Profiling result for 1000 iterations:

and identically-looped MatrixOP method gives

Total time: 1.63765, Time in Function code: 1.63765 (100%)
Top function percentages:
Function Procedure RevOddCols: 99%

Annotated Top Functions:
(Bars normalized to largest hit count)

*******************************************************************************************
Function: Procedure RevOddCols; Percent total 99%
*******************************************************************************************
[00]          	|function RevOddCols(inwave)	//	creates 'wrev'
[00]          	|	wave inwave
[04]*         	|	MatrixOP/O widx = indexCols(inwave)
[95]**********	|	MatrixOP/O wrev = inwave*equal(mod(widx,2),0) + reverseCols(inwave*mod(widx,2)) 
[00]          	|end	

s.r.chinn wrote:

Sometimes the effort of Parsing MatrixOP pays off. For the (200 row, 298 col) case cited above, the point-index method gives Profiling result for 1000 iterations:

Try adding the MultiThread keyword in front of the wave assignment statement in RevOddColsP. Depending on your processor, you might find that to be faster than the MatrixOP version. I did, with a 4 core/8 thread processor.

This would be my approach. I used redimension to separate odd and even columns. I didn't check the speed.

gives

•timeme()
  elaspsed 0.427753, crc 4151104622
  elaspsed 0.19668, crc 4151104622
  elaspsed 0.12099, crc 4151104622

So it basically depends how many cores which solution is the best. Here I'm having 12.

olelytken wrote:

This would be my approach. I used redimension to separate odd and even columns. I didn't check the speed.

Function Test()

    //  Creates a dummy wave
    Variable NumRows=200
    Variable NumCols=298
    Make/O/N=(NumRows, NumCols) root:WaveA/WAVE=WaveA  
    WaveA[][]=p
   
    //  Adds every second column to the bottom of the previous column
    Redimension/N=(NumRows*NumCols) WaveA
    Redimension/N=(NumRows*2, NumCols/2) WaveA
   
    //  Makes a copy of the bottom half of the wave corresponding to the odd columns
    Duplicate/O/R=[NumRows, *][] WaveA, root:OddColumns/WAVE=OddColumns
   
    //  Reverses the odd columns
    Reverse /DIM=0 OddColumns
   
    //  Adds the odd columns back into the wave
    ImageTransform /INSI=OddColumns /INSX=(NumRows)  /INSY=0 insertImage WaveA
   
    //  Restores the original number of columns and rows
    Redimension/N=(NumRows*NumCols) WaveA
    Redimension/N=(NumRows, NumCols) WaveA

    //  Looks at the result
    Edit WaveA
end

 

A quick test on my 10-year-old computer gives 0.00014 seconds

Just to close the loop with Adam's suggesting using MultiThread (in my 4-core cpu), 1000 iterations (divide times  by 1000)

and with a more efficient MatrixOp modification

Your mileage may vary (with number of cores, matrix dimensions, etc.)