Add missing operations

[ergomorphic]

New operations in SigmaPredef

See spec

New methods for various objects

See spec

Unary operations (// Testnet2)

! : SBoolean => SBoolean  // logical Not 
- : SNumeric => SNumeric  // negation operation
~ : SNumeric => SNumeric  // bitwise inversion of all bits

Bitwise operations (// Testnet2)

^ : (SBoolean, SBoolean) => SBoolean // logical XOR  

| : (SNumeric, SNumeric) => SNumeric // bitwise OR for all numeric types 
& : (SNumeric, SNumeric) => SNumeric // bitwise AND for all numeric types 
^ : (SNumeric, SNumeric) => SNumeric // bitwise XOR for all numeric types 

/** Returns this value bit-shifted right by the specified number of bits, 
filling in the left bits with the same value as the left-most bit of this. */
>> : (SNumeric, SNumeric) => SNumeric 

/** Returns this value bit-shifted left by the specified number of bits, 
filling in the new right bits with zeroes. */
<< : (SNumeric, SNumeric) => SNumeric 

/** Returns this value bit-shifted right by the specified number of bits, 
filling in the new left bits with zeroes. */
>>> : (SNumeric, SNumeric) => SNumeric 

/** Returns this collection bit-shifted left by the specified number of bits, 
    filling in the new right bits with zeroes. The size of collection is preserved. */
<< : (Coll[Boolean], SInt) => Coll[Boolean]

/** Returns this collection bit-shifted right by the specified number of bits, 
filling in the left bits with the same value as the left-most bit of this. 
The size of collection is preserved.*/
>> : (Coll[Boolean], SInt) => Coll[Boolean]

/** Returns this collection bit-shifted right by the specified number of bits, 
filling in the new left bits with zeroes. The size of collection is preserved.*/
>>> : (Coll[Boolean], SInt) => Coll[Boolean]

Operation to be replaces/renamed

Existing Exponentiate operation use symbol ^ which should be used for bitwise XOR instead.
See method SGroupElement.exp above.

Using bitwise operations and zip it is possible to implement existing Xor for collections (symbol |)

def Xor[T](c1: Coll[T], c2: Coll[T]): Coll[T] = c1.zipWith(c2, { (x, y) => x ^ y })

UPDATE(Denys, Feb 12):

Status of the new operations in SigmaPredef:
Implemented in parser:

• xorOf;
• byteArrayToLong;
• substConstants;
• executeFromVar;
• outerJoin;
  Implemented up to the typer:
• !(logical Not);
• -(negation);
• ~ (bitwise inversion);
• ^ (logical XOR);
• | (bitwise OR for Numeric);
• & (bitwise AND for Numeric);
• ^ (bitwise XOR for Numeric);
• <<, >>, >>> (bit shifts for Numeric);
• <<, >>, >>> (shifts for Collection); Implement >> and << operations #418

Status of the new methods for various objects:

Boolean:
Not implemented:

• toByte.

Numeric:
Implemented up to the typer:

• toBytes;
• toBits;
  Not implemented(need to express "same" type):
• abs;
• compare;

BigInt:
Implemented up to the typer:

• all new methods;

Context:
Not implemented (blocked by #350, see comments);

Header and PreHeader:
Not implemented, need to move in underlying types from ergo;

AvlTree:
Not implemented;

Box:
Implemented up to the typer:

• tokens;

GroupElement:
Implemented all new methods up to the typer:

• exp;

Option:
Implemented all new methods up to the typer:

• toColl;
• flatMap;
• map, filter (costing failing, see ignored tests in SigmaCompilerTest and BasicOpsSpec);

Coll:
Implemented all new methods up to the typer.
The following new methods are implemented fully(tests in CollectionOpsSpec):

• indexOf;
• segmentLength;
• indexWhere;
• lastIndexWhere;
• zip;
• partition;
• patch;
• updated;
• updatedMany;
  The following new methods are failing in evaluation (see ignored tests in CollectionOpsSpec):
• flatMap (output array instantiation error);
• indices (method call itself ends up in the cost func graph);

[greenhat]

Moving all unfinished operations to #479