# blockIdents

Create a transparent block with some identifiers protected against evaluation

### Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

## Syntax

```blockIdents(S)(`a`)
```

## Description

`blockIdents(S)(a)` creates a transparent block which is evaluated like `a`, except that the identifiers in `S` are neither substituted by their values nor are their properties used.

`blockIdents` is a parametrized family of domains, depending on a parameter `S` which must be a set. If `d` is any block domain, `d(a)` creates a block belonging to that domain, with content `a`.

`blockIdents(S)(a)` replaces all identifiers in `a` that belong to `S` by newly created identifiers, evaluates the result and substitutes back; the final result is put into a block. In order to evaluate `a` normally before putting it into a block, use`eval(hold(blockIdents(S))(a))`.

Blocks of type `blockIdents(S)` are evaluated in the same way as their contents at the time of creation (see above).

Blocks of type `blockIndents(S)` have the same operands as their content.

Sequences can also be put into blocks.

You can create further block domains using inheritance. This particularly useful for creating own `evaluate` or `testtype` methods. See Example 6.

The call `expr``(b)` replaces all transparent blocks in `b` by their content, without evaluating that content.

In case of nested blocks, only the outermost block is removed by both `expr` and `unblock`.

## Examples

### Example 1

A block is a sort of container that protects its content against evaluation:

`y:= 1: bl:= block(1+y)`

Blocks are atomic; thus `y` and `1` are not visible as operands:

`op(bl), nops(bl)`

Although blocks are not arithmetical expressions, some basic arithmetical operations are defined for them:

```collect(x+bl+x*bl, bl); delete y, bl:```

### Example 2

Transparent blocks protect against evaluation, too:

```y:= 2: bl:=blockTransparent(x+y+z)```

However, a transparent block allows access to the operands of its content:

`op(bl,1), subs(bl, hold(y) = y)`

`delete bl, y:`

### Example 3

With a third kind of block, suppressing evaluation may be limited to certain identifiers:

```x:= 3: y:=1: blockIdents({hold(x)})(x+y)```

`delete x, y:`

### Example 4

A block may also contain a sequence; flattening is suppressed:

`block((x, y),z)`

### Example 5

The content of a block may be extracted and evaluated using `unblock`:

`y:= 1: unblock(block(y)); delete y:`

### Example 6

We want to create blocks that represent arithmetical expressions. To do this, we need our own block domain that overloads `testtype`:

```domain myblock inherits block; category Cat::BaseCategory; testtype:= (bl, T) -> if T = Type::Arithmetical or T = dom then TRUE else block::testtype(bl, T) end_if; end_domain:```

This allows us to make the number zero invisible for the evaluator by enclosing it into a block, but to retain the option to plug it into special functions:

`f := sin(x+myblock(0))`

We can now manipulate this expression, without being disturbed by automatic simplification:

`expand(f)`

` eval(unblock(%))`

## Parameters

 `a` Any object or sequence of objects `S` Set of identifiers

## Return Values

`blockIdents` creates objects of its own type.

## See Also

### MuPAD Functions

Was this topic helpful?

Get trial now