Sviuppi Qubic: aggiornamento 3 settembre 2018

• = 1;
  0 = 0;
  1 = -;
  ];
  // LUT logic: return a boolean indicating whether the two input trits are equal
  // return (trit1 == trit2);
  equal [
  -,- = 1;
  -,0 = 0;
  -,1 = 0;
  0,- = 0;
  0,0 = 1;
  0,1 = 0;
  1,- = 0;
  1,0 = 0;
  1,1 = 1;
  ];
  // LUT logic: return a boolean indicating whether the two input trits are unequal
  // return (trit1 != trit2);
  unequal [
  -,- = 0;
  -,0 = 1;
  -,1 = 1;
  0,- = 1;
  0,0 = 0;
  0,1 = 1;
  1,- = 1;
  1,0 = 1;
  1,1 = 0;
  ];
  // LUT logic: when (boolean) trit1 equals 1 return trit2 else return trit3
  // return trit1 ? trit2 : trit3;
  unequal [
  0,-,- = -;
  0,-,0 = 0;
  0,-,1 = 1;
  0,0,- = -;
  0,0,0 = 0;
  0,0,1 = 1;
  0,1,- = -;
  0,1,0 = 0;
  0,1,1 = 1;
  1,-,- = -;
  1,-,0 = -;
  1,-,1 = -;
  1,0,- = 0;
  1,0,0 = 0;
  1,0,1 = 0;
  1,1,- = 1;
  1,1,0 = 1;
  1,1,1 = 1;
  ];
  // LUT logic: return the 2rd input trit only when 1st input trit equals 1 (true)
  // return (trit1 == 1) ? trit1 : null;
  nullOrTrit [
  1,0 = 0;
  1,1 = 1;
  1,- = -;
  ];
  // sample Abra functions
  // this is a function that takes a trit vector of State [729],
  // but we don't need to constantly repeat that size since we
  // already established the size at the top of the file
  digest(state [State]) =
  // a function returns the value of its last statement,
  // which in this case is a concatenation (comma operator)
  // of the input state and the result of the transform() function
  state, transform(state, 81);
  // note that this function does not need curly braces around its single statement
  // curly braces are only necessary when grouping multiple statements
  // construct functions for all predefined types that perform
  // a similar task to the nullOrTrit LUT for those larger types
  // note that we have defined each successive type a factor 3 times bigger
  // which means we can easily define each successive type in terms of the previous one
  // every nullOrXxx function returns < val > when < t > equals 1 (true), and null otherwise
  // note that it may seem wasteful to define it this way, but when mapped to FPGA
  // these can be translated into parallel circuitry that executes them simultaneously.
  // for other architectures, Abra will allow the Abra functions to be replaced with
  // a dll function that uses optimal architecture-specific instructions.
  // we expect a library of common functions to be developed over time
  nullOrTryte(t [Bool], val [Tryte]) = {
  // concatenate the 3 separate trits via the LUT
  nullOrTrit[t, val[0]],
  nullOrTrit[t, val[1]],
  nullOrTrit[t, val[2]];
  };
  nullOrShort(t [Bool], val [Short]) = {
  // concatenate the 3 separate trytes via the previous function

// note the notation to easily specify a subrange of a trit vector
// we will start at N times the size of Tryte and have an open ended range
// which specifies to take whatever amount necessary to pass to the underlying parameter
nullOrTryte(t, val[0 * Tryte..]),
nullOrTryte(t, val[1 * Tryte..]),
nullOrTryte(t, val[2 * Tryte..]);
};
nullOrInt(t [Bool], val [Int]) = {
// concatenate the 3 separate shorts via the previous function
nullOrShort(t, val[0 * Short..]),
nullOrShort(t, val[1 * Short..]),
nullOrShort(t, val[2 * Short..]);
};
nullOrLong(t [Bool], val [Long]) = {
// concatenate the 3 separate ints via the previous function
nullOrInt(t, val[0 * Int..]),
nullOrInt(t, val[1 * Int..]),
nullOrInt(t, val[2 * Int..]);
};
nullOrHash(t [Bool], val [Hash]) = {
// concatenate the 3 separate longs via the previous function
nullOrLong(t, val[0 * Long..]),
nullOrLong(t, val[1 * Long..]),
nullOrLong(t, val[2 * Long..]);
};
nullOrState(t [Bool], val [State]) = {
// concatenate the 3 separate hashes via the previous function
nullOrHash(t, val[0 * Hash..]),
nullOrHash(t, val[1 * Hash..]),
nullOrHash(t, val[2 * Hash..]);
};
// sample old Curl implementation in Abra, just for fun
transform(state [State], round [Short]) = {
// assume subXxx() is a function that performs subtraction on trit vectors of size X
// and also returns a trit vector size X
roundMinusOne = sub9(round, 1);
// assume equalXxx() is a function that performs comparison on trit vectors of size X
// and returns a trit containing a binary boolean value of 0 (false) or 1 (true)
roundZero = equal9(roundMinusOne, 0);
// calculate the new state for this round
newState = curlRound(state);

// here comes the interesting part, we're going to use a merger operation,
// which is an operation that returns the single operand that is non-null
// note that a merger will fail when multiple operands are non-null
// this line will return newState when roundMinusOne was determined to be zero
// and null otherwise
stateOut = nullOrState(roundZero, newState);
// this line will return newState when roundMinusOne was determined to be non-zero
// and null otherwise
stateNext = nullOrState(not[roundZero], newState);
// this line will only return roundMinusone when it was non-zero and otherwise returns null
roundNext = nullOrShort(not[roundZero], roundMinusOne);
// recursively call transform to execute the next round
// note that this will only execute if either of stateNext and roundNext are non-null
// otherwise it will not execute and a null return value is assumed
// so this is essentially a conditional execution
stateFinal = transform(stateNext, roundNext);
// merge the two branches by returning the one that is non-null
// so this is kind of an implied if-then-else, because it will
// either return stateOut or stateFinal
stateOut \ stateFinal;
};
// now follows the actual implementation of a single Curl round
// LUT logic: curl the 2 input trits onto an output trit
curl [
-,- = 1;
-,0 = 0;
-,1 = -;
0,- = 1;
0,0 = -;
0,1 = 0;
1,- = -;
1,0 = 1;
1,1 = 0;
];
// a very dumb and straightforward implementation that curls all 729 state trits
curlRound(s [State]) = {
// we use the curl LUT for each of the 729 individual pairs of trits,
// and concatenate the resulting trits into a 729 trit return value
curl[s[ 0], s[364]],
curl[s[364], s[728]],
curl[s[728], s[363]],

// ... snipped 723 more lines like this ...

curl[s[366], s[ 1]],
curl[s[ 1], s[365]],
curl[s[365], s[ 0]];
};