# Integrator

**Integrators** are the essential building blocks of analog computers. They perform **integration in time**, as in `F(t) = F(0) - ʃ_0^t f(t')/k0 dt'`

. The Analog Thing features five integrators. This allows computing five integrals in a program.

Electronic analog computers typically perform integration by charging and discharging capacitors. The key difference between an integrator and a summer is the capacity in the feedback channel instead of a simple resistance. Accordingly, all integrators are also summing their inputs. For more details, please refer to Analog computing literature.

## Basic Usage of an Integrator on The Analog Thing

- Circles represent inputs, triangles represent outputs
- Analog integrators sum their inputs. That is, if you have a sum under your integral, you can save a single summer before the integrator. Otherwise, just put your integrand into the upper left input labeled with
`1`

. - There are two output slots. Just use one of them as you like.
- The
`IC`

slot stands for*initial conditions*. It is an input where you have to provide suitable initial conditions, i.e. specify what value`F(0)`

should take. As shorthands,`-1`

and`+1`

are right to the hand. If this slot is left empty,`0`

is taken as initial condition. - Beginners may ignore the slots
`SJ`

and`SLOW`

. - The integrator's constant k0 is defined as k0 = 1/(R*C), which means the unit of k0 is [1/s] (Source: "Analogrechnen" by Giloi and Lauber, on the page before page 1). For THAT's integrators the constant is k0 = 1000 s^-1 in normal mode, or k0 = 10 s^-1 in
`SLOW`

mode. - The integration time scale factor of the
`1`

inputs is 1ms (1MOhm * 1nF = 1ms). That means if you connect a`-1`

signal to a`1`

input, the output will ramp from 0 to 1 machine unit in 1ms. The`10`

inputs have a integration time scale factor of 100μs (100kOhm * 1nF = 100μs), meaning in the aforementioned scenario the signal rises ten times faster from 0 to 1 when using a`10`

input instead of a`1`

input. In`SLOW`

mode the integration time scale factors are 100ms for`1`

inputs or 10ms for`10`

inputs.

## Extended Usage of an Integrator

### Changing the integration speed

You can change the integration time scale factors `k0`

of a particular integrator by connecting `SLOW`

to `OUT`

. This increases the time scale factors of the respective integrator by a factor of approximately 100. For the constant integration scenario described above, this means the output takes 100 times longer to transition from 0 to 1 than for the same inputs with `SLOW`

disconnected.

You can also increase the time scale factor by 10, if you connect an external 10nF capacitor between `SLOW`

and `OUT`

.

### Making use of the Summing junction

To extend the number of inputs, connect the SJ panel of the integrator to the SJ panel of a XIR element. Now the other panels of the corresponding XIR element function as inputs of the connected integrator. See also XIR.

## Mathematics and Electronics about analog integration

On an electronical level, Integrators work quite similar to Summers (and Inverters, respectively), given the closed-loop operational amplifier setup. However, they feature a capacitor in the feedback channel which holds the current integration level. This makes an integrator *stateful* in contrast to the *stateless* Summers.

In the THAT circuits, you find the integrators on page File:Anathing_v1.0_base_3.pdf. As you can see there, they are implemented with ICs called `TL074H`

. See [1] for the datasheet of this chip.