Hello everyone,
I am writing some functions that will be made into a class, for doing basic
serial operations on cells (i.e. arrays of floats). The operations I have so
far are: transpose, reverse, invert, permute, shuffle.
The next function to finish is multiply, which does Boulez-style cell
multiplication. For the function to work correctly, it should remove any
duplicates from the array. Unfortunately, my brain's a little rusty right
now. I'm sure I did this in the only computer class I ever took (C++). But
I'm too sleepy to figure out the correct solution offhand, I think the ways
I'm coming up with are inefficient. Can anyone help?
I've gotten really spoiled, by usually coding these sorts of things in
Python, where its amazingly quick to do list manipulations of any kind.
Here's my code so far, which works except multiply is a dummy function:
//cellFun.ck
public class Argh
{
fun static void print(float cell[])
{
for (0 => int i; i<cell.cap(); i++)
{
<<< cell[i] >>> ;
}
}
fun static void remove (float a[], int index)
{
a.cap()-1 => int newLength;
float temp[newLength];
for (0 => int i; i < newLength; i++)
{
if (i<index)
{
a[i] => temp[i];
}
else
{
a[i+1] => temp[i];
}
}
float a[newLength];
for (0 => int i; i < newLength; i++ )
{
temp[i] => a[i];
}
}
//match
fun static int match(float cell[], float element)
{
cell.cap() => int length;
-1 => int position;
for (0 => int i; i<length; i++)
{
if (cell[i] == element)
{
i => position;
break;
}
}
return position;
}
}
fun float[] copyCell(float cell[])
{
cell.cap() => int length;
float newCell[length];
for (0 => int i; i<length; i++)
{
cell[i] => newCell[i];
}
return (newCell);
}
//transpose
fun float[] tranCell(float cell[], float amount)
{
cell.cap() => int length;
float newCell[length];
for (0 => int i; i<length; i++)
{
cell[i] + amount => newCell[i];
}
return(newCell);
}
//reverse
fun float[] revCell(float cell[])
{
cell.cap() => int length;
float newCell[length];
length - 1 => int counter;
for (0 => int i; i<length; i++)
{
cell[i]=> newCell[counter];
counter--;
}
return(newCell);
}
//invert()
fun float[] invCell(float cell[])
{
cell.cap() => int length;
float newCell[length];
cell[0] => newCell[0];
for (1 => int i; i<length; i++)
{
(2 * cell[0]) - (cell[i]) => newCell[i];
}
return(newCell);
}
//shufCell():
fun float[] shufCell(float cell[])
{
cell.cap() => int length;
copyCell(cell) @=> float newCell[];
//--- Shuffle elements by randomly exchanging each with one other.
for (0 => int i; i<length; i++)
{
std.rand2(0,length-1) => int r; // generate a random position
newCell[i] => float temp;
newCell[r] => newCell[i];
temp => newCell[r];
}
return(newCell);
}
//permCell(float cell[], int amount):
fun float[] permCell (float cell[], int amount)
{
cell.cap() => int length;
float newCell[length];
for (0=>int i; i<length; i++)
{
cell[(amount+i)%length] => newCell[i];
}
return(newCell);
}
//multiply(float cell[], float multCell[])
//unfinished
//look for a match
//store the position in a new array
fun float[] multCell (float cell[], float mult[])
{
<<<"unfinished">>>;
return [0.0];
}
//tests!!!
fun void testShiz()
{
[0.0,2.0,4.0,6.0,8.0,2.0,10.0] @=> float testCell[];
copyCell(testCell) @=> float theCopy[];
[0.0,1.0,2.0] @=> float multi[];
<<<"print cell">>>;
Argh.print(testCell);
<<<"match (return position of first occurrance of 2.0 in cell)">>>;
<<<Argh.match(testCell,2.0)>>>;
<<<"transpose cell by 2.0 (returns a copy)">>>;
Argh.print(tranCell(testCell, 2.0));
<<<"reverse cell (returns a copy)">>>;
Argh.print(revCell(testCell));
<<<"invert cell (returns a copy)">>>;
Argh.print(invCell(testCell));
<<<"shuffle cell (returns a copy)">>>;
Argh.print(shufCell(testCell));
<<<"permCell(permute by 2, returns a copy)">>>;
Argh.print(permCell(testCell, 2));
<<<"multCell (multiply by [0.0,1.0,2.0], returns a copy">>>;
Argh.print(multCell(testCell,multi));
<<<"print the original">>>;
Argh.print(testCell);
<<<"permute the original by 2 and print">>>;
permCell(testCell, 2) @=> testCell;
Argh.print(testCell);
<<<"print the copy">>>;
Argh.print(theCopy);
}
testShiz();