-->
Numeric Expressions
Since the LCD id x(x - 1)(x - 2). 2/x. (x - 1)(x - 2)/((x - 1)(x - 2)) + 2/(x - 1). x(x - 2)/(x(x - 2)) - 2/(x - 2). x(x - 1)/(x(x - 1)) = (2(x² - 3x + 2) + 2x. Writing expressions with variables Get 5 of 7 questions to level up! Level up on the above skills and collect up to 400 Mastery points Start quiz. 1-7 The Distributive Property 7-1 Zero and Negative Exponents 8-2 Multiplying and Factoring 10-2 Simplifying Radicals 11-3 Dividing Polynomials 12-7 Theoretical and Experimental Probability Absolute Value Equations and Inequalities Algebra 1 Games Algebra 1 Worksheets algebra review solving equations maze answers Cinco De Mayo Math Activity.
Numeric expressions are expressions of type
Int
, BigInt
, or Double
.That is, they are either integer or floating-point numbers.Int
literals in Q# are written as a sequence of digits.Hexadecimal and binary integers are supported and written with a 0x
and 0b
prefix, respectively.BigInt
literals in Q# have a trailing l
or L
suffix.Hexadecimal big integers are supported and written with a '0x' prefix.Thus, the following are all valid uses of BigInt
literals:Double
literals in Q# are floating-point numbers written using decimal digits.They can be written with or without a decimal point, .
, or an exponential part indicated with 'e' or 'E' (after which only a possible negative sign and decimal digits are valid).The following are valid Double
literals: 0.0
, 1.2e5
, 1e-5
.Given an array expression of any element type, you can form an
Int
expression using the Length
built-in function, with the array expression enclosed in parentheses.For example, if a
is bound to an array, then Length(a)
isan integer expression.If b
is an array of arrays of integers, Int[][]
, thenLength(b)
is the number of sub-arrays in b
, and Length(b[1])
is the number of integers in the second sub-array in b
.Given two numeric expressions of the same type,the binary operators
+
, -
, *
, and /
may be used to forma new numeric expression.The type of the new expression is the same as the types of theconstituent expressions.Given two integer expressions, use the binary operator
^
(power)to form a new integer expression.Similarly, you can also use ^
with two double expressions to forma new double expression.Finally, you can use ^
with a big integer on the left andan integer on the right to form a new big integer expression.In this case, the second parameter must fit into 32 bits;if not, it raises a runtime error.Given two integer or big integer expressions, form a new integer orbig integer expression using the
%
(modulus),&&&
(bitwise AND), |||
(bitwise OR), or ^^^
(bitwise XOR) operators.Given either an integer or big integer expression on the left,and an integer expression on the right, use the
<<<
(arithmetic left shift)or >>>
(arithmetic right shift) operators to createa new expression with the same type as the left-hand expression.The second parameter (the shift amount) to either shift operationmust be greater than or equal to zero; the behavior for negativeshift amounts is undefined.The shift amount for either shift operation must also fit into32 bits; if not, it raises a runtime error.If the number shifted is an integer, then the shift amountis interpreted
mod 64
; that is, a shift of 1 and a shift of 65have the same effect.For both integer and big integer values, shifts are arithmetic.Shifting a negative value either left or right results in a negative number.That is, shifting one step to the left or right is the same asmultiplying or dividing by 2, respectively.
Integer division and integer modulus follow the same behavior for negative numbers as C#. That is,
a % b
always has the same sign as a
, and b * (a / b) + a % b
always equals a
. For example:A | B | A / B | A % B |
---|---|---|---|
5 | 2 | 2 | 1 |
5 | -2 | -2 | 1 |
-5 | 2 | -2 | -1 |
-5 | -2 | 2 | -1 |
Big integer division and modulus operations work the same way.
Given any numeric expression, you can form a new expression using the
-
unary operator.The new expression is the same type as the constituent expression.Given any integer or big integer expression, you can form a new expression of the same type using the
~~~
(bitwise complement) unary operator.Boolean Expressions
The two
Bool
literal values are true
and false
.Given any two expressions of the same primitive type, the and
!=
binary operators may be used to construct a Bool
expression.The expression is true if the two expressions are equal and false if not.Values of user-defined types may not be compared, only their unwrapped values can be compared.For example, using the 'unwrap' operator
!
(explained in detail at Types in Q#),Equality comparison for
Qubit
values is identity equality;that is, whether the two expressions identify the same qubit.The states of the two qubits are not compared, accessed, measured, or modifiedby this comparison.Equality comparison for
Double
values may be misleadingdue to rounding effects.For example, 49.0 * (1.0/49.0) != 1.0
.Given any two numeric expressions, the binary operators
>
, <
, >=
, and <=
may be used to construct a new Boolean expressionthat is true if the first expression is respectively greater than, less than,greater than or equal to, or less than or equal to the second expression.Given any two Boolean expressions, use the
and
binary operator to construct a new Boolean expression that is true if both of the two expressions are true. Likewise, using the or
operator creates an expression that is true if either of the two expressions is true.Given any Boolean expression, the
not
unary operator may be used to constructa new Boolean expression that is true if the constituent expression is false.String expressions
Q# allows strings to be used in the
fail
statement (explained in Control Flow) and in the Message
standard function. The specific behavior of the latter depends on the simulator used but typically writes a message to the host console when called during a Q# program.Strings in Q# are either literals or interpolated strings.
String literals are similar to simple string literals in most languages:a sequence of Unicode characters enclosed in double-quotes
' '
.Inside of a string, use the backslash character
to escapea double-quote character ('
), or to insert a new-line ( n
), a carriagereturn (r
), or a tab (t
).For example:Interpolated strings
The Q# syntax for string interpolations is a subset of the C# syntax. Following are the key points as they pertain to Q#:
- To identify a string literal as an interpolated string, prepend it with the
$
symbol. There can be no white space between the$
and the'
that starts a string literal. - The following is a basic example using the
Message
function to write the result of a measurement to the console, alongside other Q# expressions.
- Any valid Q# expression may appear in an interpolated string.
- Expressions inside of an interpolated string follow Q# syntax, not C# syntax. The most notable distinction is that Q# does not support verbatim (multi-line) interpolated strings.
For more details about the C# syntax, see Interpolated Strings.
Range Expressions
Given any three
Int
expressions start
, step
, and stop
, the expression start . step . stop
is a range expression whose first element is start
, second element is start+step
, third element is start+step+step
, and so on, until you pass stop
.A range may be empty if, for example, step
is positive and stop < start
.The range is inclusive at both ends. That is, if the difference between
start
and stop
is an integer multiple of step
, the last element of the range will be stop
.Given any two
Int
expressions start
and stop
, the expression start . stop
is a range expression that is equal to start . 1 . stop
.Note that the implied step
is +1 even if stop
is less than start
;in such a case, the range is empty.Some example ranges are:
1.3
is the range 1, 2, 3.2.2.5
is the range 2, 4.2.2.6
is the range 2, 4, 6.6.-2.2
is the range 6, 4, 2.2.1
is the empty range.2.6.7
is the range 2.2.2.1
is the empty range.1.-1.2
is the empty range.
Qubit Expressions
The only
Qubit
expressions are symbols that are bound to Qubit
valuesor array elements of Qubit
arrays.There are no Qubit
literals.Pauli Expressions
The four
Pauli
values, PauliI
, PauliX
, PauliY
, and PauliZ
,are all valid Pauli
expressions.Other than that, the only
Pauli
expressions are symbols that arebound to Pauli
values or array elements of Pauli
arrays.Result Expressions
The two
Result
values, One
and Zero
, are valid Result
expressions.Other than that, the only
Result
expressions are symbols that arebound to Result
values or array elements of Result
arrays.In particular, note that One
is not the same as the integer 1
,and there is no direct conversion between them.The same is true for Zero
and 0
.Tuple Expressions
A tuple literal is a sequence of element expressions of the appropriate type,separated by commas, enclosed in parentheses.For example,
(1, One)
is an (Int, Result)
expression.Wolfram mathematica 12 0. Other than literals, the only tuple expressions are symbols that are bound totuple values, array elements of tuple arrays, and callable invocations thatreturn tuples.
User-Defined Type Expressions
A literal of a user-defined type consists of the type name followed by atuple literal of the type’s base tuple type.For example, if
IntPair
is a user-defined type based on (Int, Int)
,then IntPair(2, 3)
is a valid literal of that type.Other than literals, the only expressions of a user-defined type are symbolsthat are bound to values of that type, array elements of arrays of that type,and callable invocations that return that type.
Unwrap Expressions
In Q#, the unwrap operator is a trailing exclamation mark
!
.For example, if IntPair
is a user-defined type with the underlying type (Int, Int)
and s
is a variable with value IntPair(2, 3)
, then s!
is (2, 3)
.For user-defined types defined in terms of other user-defined types, you can repeat the unwrap operator. For example,
s!!
indicates thedoubly-unwrapped value of s
.Thus, if WrappedPair
is a user-defined type with underlying type IntPair
, andt
is a variable with value WrappedPair(IntPair(1,2))
, then t!!
is (1,2)
.The
!
operator has higher precedence than all other operators other than[]
for array indexing and slicing.!
and []
bind positionally; that is, a[i]![3]
is read as((a[i])!)[3]
: take the i
th element of a
, unwrap it, and thenget the 3rd element of the unwrapped value (which must be an array).The precedence of the
!
operator has one impact that might not be obvious.If a function or operation returns a value that then gets unwrapped, thefunction or operation call must be enclosed in parentheses so that theargument tuple binds to the call rather than to the unwrap.For example:Array Expressions
An array literal is a sequence of one or more element expressions, separated by commas, enclosed in square brackets
[]
.All elements must be compatible with the same type.Given two arrays of the same type, use the binary
+
operator to form a new array that is the concatenation of the two arrays.For example, [1,2,3] + [4,5,6]
= [1,2,3,4,5,6]
.Array Creation
Given a type and an
Int
expression, use the new
operator to allocate a new array of the given size.For example, new Int[i + 1]
allocates a new Int
array with i + 1
elements.Empty array literals, such as
[]
, are not allowed.Instead, you can create an array of length zero by using new T[0]
, where T
is a placeholder for a suitable type.The elements of a new array initialize to a type-dependent default value.In most cases, this is some variation of zero.
For qubits and callables, which are references to entities, there is no reasonable default value.Thus, for these types, the default is an invalid reference that you cannot use without causing a runtime error, similar to a null reference in languages such as C# or Java.Arrays containing qubits or callables must be initialized with non-default values before you can use their elements safely.For suitable initialization routines, see Microsoft.Quantum.Arrays.
The default values for each type are:
Type | Default |
---|---|
Int | 0 |
BigInt | 0L |
Double | 0.0 |
Bool | false |
String | ' |
Qubit | invalid qubit |
Pauli | PauliI |
Result | Zero |
Range | The empty range, 1.1.0 |
Callable | invalid callable |
Array['T] | 'T[0] |
Tuple types initialize element-by-element.
Array Elements
Given an array expression and an
Int
expression, form a new expression using the array element operator []
.The new expression is the same type as the element type of the array.For example, if a
is bound to an array of type Double
, then a[4]
is a Double
expression.If the array expression is not a simple identifier, you must enclose it in parentheses to select an element.For example, if
a
and b
are both arrays of type Int
, an element from the concatenation is expressed as:All arrays in Q# are zero-based.That is, the first element of an array
a
is always a[0]
.Array Slices
Given an array expression and a
Range
expression, form a new expression using the array slice operator [ ]
.The new expression is the same type as the array and contains the array items indexed by the elements of the Range
, in the order defined by the Range
.For example, if a
is bound to an array of type Double
, then a[3.-1.0]
is a Double[]
expression that contains the first four elements of a
but in the reverse order as they appear in a
.If the
Range
is empty, then the resulting array slice is zero length.Just as with referencing array elements, if the array expression is not a simple identifier, you must enclose it in parentheses to slice it.For example, if
a
and b
are both arrays of type Int
, a slice from the concatenation is expressed as: One chat 4 1 – all in one messenger web.Inferred start/end values
Starting with our 0.8 release, we support contextual expressions for range slicing. In particular, you may omit range start and end values in the context of a range slicing expression. In that case, the compiler applies the following rules to infer the intended delimiters for the range:
- If the range start value is omitted, then the inferred start value
- is zero if no step is specified or the specified step is positive.
- is the length of the sliced array minus one if the specified step is negative.
- If the range end value is omitted, then the inferred end value
- is the length of the sliced array minus one if no step is specified or the specified step is positive.
- is zero if the specified step is negative.
Some examples are:
Copy-and-Update Expressions
Since all Q# types are value types (with the qubits taking a somewhat special role), formally a 'copy' is created when a value is bound to a symbol or when a symbol is rebound. That is to say, the behavior of Q# is the same as if a copy were created using an assignment operator.
Of course, in practice, only the relevant pieces are recreated as needed. This affects how you copy arrays because it is not possible to update array items. To modify an existing array requires leveraging a copy-and-update mechanism.
You can create a new array from an existing array via copy-and-update expressions, which use the operators
w/
and <-
.A copy-and-update expression is an expression of the form expression1 w/ expression2 <- expression3
, whereexpression1
must be typeT[]
for some typeT
.expression2
defines which indices in the array specified inexpression1
to modify.expression2
must be either typeInt
or typeRange
.expression3
is the value(s) used to update elements inexpression1
, based on the indices specified inexpression2
. Ifexpression2
is typeInt
,expression3
must be typeT
. Ifexpression2
is typeRange
,expression3
must be typeT[]
.
For example, the copy-and-update expression
arr w/ idx <- value
constructs a new array with all elements set to the corresponding elements in arr
, except for the element(s) specified by idx
, which is set to the value(s) in value
.Given
arr
contains the array [0,1,2,3]
, thenarr w/ 0 <- 10
is the array[10,1,2,3]
.arr w/ 2 <- 10
is the array[0,1,10,3]
.arr w/ 0.2.3 <- [10,12]
is the array[10,1,12,3]
.
Copy-and-update expressions for named items
Similar expressions exist for named items in user-defined types.
For example, consider the type
If
c
contains the value of type Complex(1., -1.)
, then c w/ Re <- 0.
is an expression of type Complex
that evaluates to Complex(0., -1.)
.Jagged Arrays
A jagged array, sometimes called an 'array of arrays,' is an array whose elements are arrays.The elements of a jagged array can be of different sizes.The following example shows how to declare and initialize a jagged array representing a multiplication table.
Arrays of callables
You can also create an array of callables.
- If the common element type is an operation or function type, all of the elements must have the same input and output types.
- The element type of the array supports any functors that are supported by all of the elements.For example, if
Op1
,Op2
, andOp3
all areQubit[] => Unit
operations, butOp1
supportsAdjoint
,Op2
supportsControlled
, andOp3
supports both:[Op1, Op2]
is an array of(Qubit[] => Unit)
operations.[Op1, Op3]
is an array of(Qubit[] => Unit is Adj)
operations.[Op2, Op3]
is an array of(Qubit[] => Unit is Ctl)
operations.
However, while the operations
(Qubit[] => Unit is Adj)
and (Qubit[] => Unit is Ctl)
have the common base type of (Qubit[] => Unit)
, arrays of these operations do not share a common base type.For example,
[[Op1], [Op2]]
would currently raise an error because it attempts to create an array of the two incompatible array types (Qubit[] => Unit is Adj)[]
and (Qubit[] => Unit is Ctl)[]
.For more information on callables, see Callable expressions on this page or Operations and Functions in Q#.
Conditional Expressions
Given two expressions of the same type and a Boolean expression, form a conditional expression using the question mark,
?
, and the vertical bar |
. Given ab ? c | d
, the value of the conditional expression is c
if ab
is true and d
if it is false.Conditional expressions with callables
Conditional expressions may evaluate to operations that have the same inputs and outputs but support different functors. In this case, the type of the conditional expression is an operation with inputs and outputs that support any functors supported by both expressions.For example, if
Op1
, Op2
, and Op3
all are Qubit[]=>Unit
, but Op1
supports Adjoint
, Op2
supports Controlled
, and Op3
supports both:flag ? Op1 | Op2
is a(Qubit[] => Unit)
operation.flag ? Op1 | Op3
is a(Qubit[] => Unit is Adj)
operation.flag ? Op2 | Op3
is a(Qubit[] => Unit is Ctl)
operation.
If either of the two possible result expressions include a function or operation call, that call only takes place if that result is the one that is the value of the call. For example, in the case
ab ? C(qs) | D(qs)
, if ab
is true, then the C
operation is invoked, and if it is false then only the D
operation is invoked. This approach is similar to short-circuiting in other languages.Callable Expressions
A callable literal is the name of an operation or function defined in the compilation scope. For example,
X
is an operation literal that refers to the standard library X
operation, and Message
is a function literal that refers to the standard library Message
function.Expressions 1 2 2 0
If an operation supports the
Adjoint
functor, then Adjoint op
is an operation expression.Similarly, if the operation supports the Controlled
functor, then Controlled op
is an operation expression.For more information about the types of these expressions, see Calling operation specializations.Functors (
Adjoint
and Controlled
) bind more closely than all other operators, except for the unwrap operator !
and array indexing with [ ]
.Thus, the following are all valid, assuming that the operations support the functors used:Type-parameterized callable expressions
You can use a callable literal as a value, for example, to assign it to a variable or pass it to another callable. In this case, if the callable has type parameters, you must provide the parameters as part of the callable value.
A callable value cannot have any unspecified type parameters. For example, if
Fun
is a function with the signature 'T1->Unit
:Callable Invocation Expressions
Given a callable expression (operation or function) and a tuple expression of the input type of the callable's signature, you can form an invocation expression by appending the tuple expression to the callable expression.The type of the invocation expression is the output type of the callable's signature.
Expressions 1 2 2 X 2
For example, if
Op
is an operation with the signature ((Int, Qubit) => Double)
, Op(3, qubit1)
is an expression of type Double
.Similarly, if Sin
is a function with the signature (Double -> Double)
, Sin(0.1)
is an expression of type Double
.Finally, if Builder
is a function with the signature (Int -> (Int -> Int))
, then Builder(3)
is a function from Int
to Int
.Invoking the result of a callable-valued expression requires an extra pair of parentheses around the callable expression.Thus, to invoke the result of calling
Builder
from the previous paragraph, the correct syntax is:When invoking a type-parameterized callable, you can specify the actual type parameters within angle brackets
< >
after the callable expression.This action is usually unnecessary as the Q# compiler infers the actual types.However, it is required for partial application if a type-parameterized argument is left unspecified.It is also useful when passing operations with different functor supports to a callable.For example, if
Func
has signature ('T1, 'T2, 'T1) -> 'T2
, Op1
and Op2
have signature (Qubit[] => Unit is Adj)
, and Op3
has signature (Qubit[] => Unit)
, to invoke Func
with Op1
as the first argument, Op2
as the second, and Op3
as the third:The type specification is required because
Op3
and Op1
have different types, so the compiler will treat this as ambiguous without the specification.Operator Precedence
- All binary operators are right-associative, except for
^
. - Brackets,
[ ]
, for array slicing and indexing, bind before any operator. - The functors
Adjoint
andControlled
bind after array indexing but before all other operators. - Parentheses for operation and function invocation also bind before any operator but after array indexing and functors.
Q# operators in order of precedence, from highest to lowest:
Operator | Arity | Description | Operand Types |
---|---|---|---|
trailing ! | Unary | Unwrap | Any user-defined type |
- , ~~~ , not | Unary | Numeric negative, bitwise complement, logical negation | Int , BigInt or Double for - , Int or BigInt for ~~~ , Bool for not |
^ | Binary | Integer power | Int or BigInt for the base, Int for the exponent |
/ , * , % | Binary | Division, multiplication, integer modulus | Int , BigInt or Double for / and * , Int or BigInt for % |
+ , - | Binary | Addition or string and array concatenation, subtraction | Int , BigInt or Double , additionally String or any array type for + |
<<< , >>> | Binary | Left shift, right shift | Int or BigInt |
< , <= , > , >= | Binary | Less-than, less-than-or-equal, greater-than, greater-than-or-equal comparisons | Int , BigInt or Double |
, != | Binary | equal, not-equal comparisons | any primitive type |
&&& | Binary | Bitwise AND | Int or BigInt |
^^^ | Binary | Bitwise XOR | Int or BigInt |
||| | Binary | Bitwise OR | Int or BigInt |
and | Binary | Logical AND | Bool |
or | Binary | Logical OR | Bool |
. | Binary/Ternary | Range operator | Int |
? | | Ternary | Conditional | Bool for the left-hand-side |
w/ <- | Ternary | Copy-and-update | See Copy-and-update expressions |
Next steps
2 1 2 In Fractions
Now that you can work with expressions in Q#, move on to Operations and Functions in Q# to learn how to define and call operations and functions.
2 Thes 2 1 3
Drawing on more than a decade of experience in the field of digital audio mixing, the Soundcraft® Si Expression exploits some of the newest DSP, component technology and manufacturing techniques to deliver our most powerful cost effective digital console ever! Each console in the range is identical in its feature set so your only choice is how many faders and local mic amps you want. With a range covering the super portable 19' rack mount Expression 1 to the mighty Si Expression 3 with its 30+2 faders and 32 mic/line inputs there is a model to meet all needs.
The Si Expression 1 features 16 recallable mic pre amps (24 on Si Expression 2 and 32 on Si Expression 3) plus 4 line inputs, 4 internal stereo FX returns, AES in, and a 64x64 expansion slot offering more than enough scope to use every one of the 66 input processing channels. Every input processing channel has dedicated processing for high pass filter, input delay, gate, compressor and four band EQ whilst keeping it under control is a comprehensive automation system augmented with four mute groups and FaderGlow™ to light the way so you are never lost.
All Si Expression consoles have busses, output processing and connectivity to match the versatility of the inputs; the 14 aux/group mixes can be configured as 14 mono mixes, 8 mono plus 6 stereo mixes or almost anything in between, whilst the 4 matrix mixes can be mono or stereo as needed. The bus and matrix mixes are complemented with four more mix busses dedicated to the internal Lexicon FX processors all in addition to the left, right and centre busses. Each bus mix features a compressor, 4 band EQ, BSS graphic EQ and delay always available all of the time. Output connectivity is comprehensive with all models featuring 16 balanced line outputs, headphone monitor out, AES out and of course the 64x64 option slot.
To complement the channel and bus processing all Si Expression consoles integrate four stereo Lexicon FX processors based on the MX400 providing a wealth of sounds, user adjustable parameters and dedicated tap-tempo keys. As the FX are hardware based, use of all the effects, even on the most demanding programmes does not affect other processing in any way and all dynamics, EQs, filters, delays, and GEQs remain available regardless what you are doing.
Flexible onboard and expansion I/O options ensure your Si Expression integrates effortlessly with other system components utilising any of the ViSi Connect™ Si series option cards including MADI USB Combo, BSS Digital Audio Bus (BLU Link), Dante™, CAT5 or optical MADI, AVIOM™, CobraNet™ and others. The MADI card, as well as being an interface to multi-track recording systems or plug-in systems like the Soundcraft Realtime Rack™, enables users to link the Si Expression to any of the Soundcraft or Studer stageboxes to extend the I/O power and flexibility. Adding a stagebox to an Si Expression actually increases the number of channels you can mix at once not just how many inputs you have available to choose from! It is said 'Power is nothing without control' and here the Si Expression excels with a comprehensive but 'simple to use' control surface incorporating a dedicated control for every parameter, a row of global mode encoders and colour touch screen ensuring operation is quick and easy.
As you would expect from any Soundcraft digital mixer the facilities are extensive and include legendary audio quality courtesy of the latest generation EMMA™ DSP processor, the same DSP platform that has helped propel previous Soundcraft Si series consoles to fame. All this power united with reliability, flexibility and usability puts the Si Expression in a class of its own.
The Si Expression 1 features 16 recallable mic pre amps (24 on Si Expression 2 and 32 on Si Expression 3) plus 4 line inputs, 4 internal stereo FX returns, AES in, and a 64x64 expansion slot offering more than enough scope to use every one of the 66 input processing channels. Every input processing channel has dedicated processing for high pass filter, input delay, gate, compressor and four band EQ whilst keeping it under control is a comprehensive automation system augmented with four mute groups and FaderGlow™ to light the way so you are never lost.
All Si Expression consoles have busses, output processing and connectivity to match the versatility of the inputs; the 14 aux/group mixes can be configured as 14 mono mixes, 8 mono plus 6 stereo mixes or almost anything in between, whilst the 4 matrix mixes can be mono or stereo as needed. The bus and matrix mixes are complemented with four more mix busses dedicated to the internal Lexicon FX processors all in addition to the left, right and centre busses. Each bus mix features a compressor, 4 band EQ, BSS graphic EQ and delay always available all of the time. Output connectivity is comprehensive with all models featuring 16 balanced line outputs, headphone monitor out, AES out and of course the 64x64 option slot.
To complement the channel and bus processing all Si Expression consoles integrate four stereo Lexicon FX processors based on the MX400 providing a wealth of sounds, user adjustable parameters and dedicated tap-tempo keys. As the FX are hardware based, use of all the effects, even on the most demanding programmes does not affect other processing in any way and all dynamics, EQs, filters, delays, and GEQs remain available regardless what you are doing.
Flexible onboard and expansion I/O options ensure your Si Expression integrates effortlessly with other system components utilising any of the ViSi Connect™ Si series option cards including MADI USB Combo, BSS Digital Audio Bus (BLU Link), Dante™, CAT5 or optical MADI, AVIOM™, CobraNet™ and others. The MADI card, as well as being an interface to multi-track recording systems or plug-in systems like the Soundcraft Realtime Rack™, enables users to link the Si Expression to any of the Soundcraft or Studer stageboxes to extend the I/O power and flexibility. Adding a stagebox to an Si Expression actually increases the number of channels you can mix at once not just how many inputs you have available to choose from! It is said 'Power is nothing without control' and here the Si Expression excels with a comprehensive but 'simple to use' control surface incorporating a dedicated control for every parameter, a row of global mode encoders and colour touch screen ensuring operation is quick and easy.
As you would expect from any Soundcraft digital mixer the facilities are extensive and include legendary audio quality courtesy of the latest generation EMMA™ DSP processor, the same DSP platform that has helped propel previous Soundcraft Si series consoles to fame. All this power united with reliability, flexibility and usability puts the Si Expression in a class of its own.