Parallel computings by the computer group on data streams

Introduction

With development of microelectronics everything is more notable deficit of programming languages of the task solved in parallel by the working microcomputers without programming of their interaction. The version of such language, not simple for perception, was offered by me earlier ("http://tadviser.ru/a/150588"):

1. The main construction of language – superposition of functions of ƒ (_{ƒ (...)} 1, ƒ₂ (...) …, _ƒn (...)), in which everyone _ƒi (...) with the same structure, as well as ƒ there are all microcomputers working in parallel that usually [1] is considered impossible for the digital systems.
2. At data of the same layered design 1 names of ƒ and _ƒi - an essence atoms: numbers, lines, dates, etc. Unlike lisp [2.3] the dynamically distributed memory (DDM) under structure members 1 allows direct access to _ƒi node (...) on value i.
3. On inputs (arguments) of function _{of ƒi} (i=1-n) flows, each of elements - atoms and/or links to structures 2 which results of serial processing _ƒi transfers (flow) to the corresponding input of ƒ at the same time arrive.
4. The sequence of indexes - a data stream and, in particular, defines now a way on a hierarchical structure from its root (top) to an element on any hierarchy level. So indexing of elements of multidimensional matrixes extends to any hierarchical structures.
5. The element in a flow is followed by properties (sv-you), the elements of flows determined by its structure or created obviously during processing, for example, when comparing. On inputs (arguments) and exits _{of ƒi} the filters which are passing the elements answering required to sv-you are installed.
6. The main syntactically can complement the defined exit of function with others - canals on which the results of calculations answering to the condition set by the filter (see above) move. 1 of these channels define other functions of the same expression as own inputs (arguments) - similarity of Chanal of the Occam language [5].
7. For designing of function primitives - the built-in (not programmed) functions are offered: filters (item 5), generators (sources) of flows and also for synchronous and asynchronous processing of flows with connection of a primitive of _Calc with an argument - the microprogram in the form of the decision table, etc.
8. The construction of function of ƒ developed by the user on means of item 7 has the same appearance 1 in which _ƒi are already primitives with a lot of settings and microprograms of _Calc in the form of their arguments. The received construction of function together with a form of the address to her can be saved in library and then along with primitives to use in expressions of type 1.
   

Unfortunately implementation of 7 and 8 concepts 1-6 turned out not such idle time for perception that forced to continue search. The simplest solution managed to be found, having defined their inner hierarchical structure, uniform for all functions of ƒ and _ƒi (see river 2).
      Now not function _{of ƒi} in expression 1 is represented to a separate microcomputer, and each of the elements of its inner unified pattern which are also working in parallel and all on the same concept of the flows created, moving and processed now is explicit also in this structure.
      With increase in parallelization of calculations and high-speed performance programming language level is raised, need practically for all built-in functions, including _Calc with microprograms disappeared, if necessary having described them as user and having placed in library. There is no need and for the separate description of a form of the appeal (call) to _ƒi.
      Unfortunately essentially new and certainly necessary sooner or later others as I for this purpose did not have time, forces and group of the corresponding contractors any more should complete implementation of all this.

1. A heritage minimum from the first version of the project

Initial concepts (1-6) of Introduction remained the same. As well as earlier ("http://tadviser.ru/a/149691") for structure declaration of data and language is used Backus Nowra metasymbolics. In addition in low-fat brackets [...] a part of the description which can be absent consists. In brackets {...} a part of the description which can be absent or repeat (iteration) joins. In brackets/.../-the list designated by characters sv-in a structure member which begins the character of' %'. The code preceding designation of a sv-v' ~' denies its existence.

1.1. Uniform data structure and programs

<Structure>:: = [<atom>] <Layer>
<Layer>:: = ([<Node>] {, <Node> })

The layer can be empty - without nodes - ().

<Node>:: = [<Name index>:] <Indefinite>|[<name index>:] <Structure>
<Indefinite>:: = #

In addition to index 0, 1, 2..., defining its number in a layer one after another, the node can have a name index, unique within a layer, similar to hash [2].
Coding of structure - a node differs from accepted in lisp: it is couple of links

UKA – the pointer of atom and UKS – the pointer of a layer of the following hierarchy level.

Lack of atom and/or layer we will define further as UKA=0 and/or UKS =0, simultaneous UKA=0 and UKS =0 - as indefinite (#) a node. Actually UKA and UKS are links to separate blocks (BP) of the dynamically distributed memory (DDM), respectively, with atom and a layer, and BP with a layer contains codes (UKA, UKS pairs) of its nodes of a layer and in addition to access on a name index (if it is defined) allows direct access to these codes by their indexes (to numbers one after another) 0, 1, 2, … (item 2.5).

1.2. Flows and properties of their elements

Physically the flow consists of the elements in turn transferred from the same exit (or the channel) one function of expression (superposition of functions) on the same input (argument) - the register another in one of the following types:

Atom / %A/is the transferred its value directly without use of DRP.

R-value/%R/-couple of links UKA and UKS (item 1.1). %a[tom] following %R of a sv-v and %l[ay] (%Ral) specify, respectively, availability of atom and a layer of a node according to these links or their absence (UKA=0 and/or UKS =0) preceding sv-in the code '~'. At %R ~ ~ l the node is considered an indefinite and the value is shorter than it and sv-in it is possible to designate as '#'.

The V-value/%V [li] / - determines number - index/%i/of a node (R-value) in a layer by UKS/%l/. Thus, it is pair (UKS, the index) - the link to R-value (briefly Rzn-e).

Attention! The V-value (briefly Vzn-e) fixes still the problems of modern L-languages mentioned by Barron [2], for example, different interpretation of X in the left and right parts of operator X: = X+1. Now this operator it is possible to repeat also in flows, despite of statements [4] about impossibility of it ("substitutions" in terminology [4]) in stream computers: now can be elements of a flow also Vzn-I.

1.2.1. Determination of properties of elements

And about sv-Vakh, unambiguously defined value of an element both flow, and any structure and therefore not requiring their maintaining and storage near this element:

1) Sv-va %Ra and %A of elements are followed by sv-you their atoms - type of their values:
- integer numbers / %i [nter]/and fractional / %f[loat]/,
- line / %s [tring] / ("line"),
- date / %d [ate]/,
- identifiers / %n [ame]/names indexes, functions, channels (exits of functions), identifiers of primitives,
- % atom { [~] <sv-in> } / %p[ercent] / from a set sv-in or their denials.

P.S. In the described set sv-in can is not allowed at described by them an object at the same time. For example, the number cannot be at the same time date, or I Vzn-eat with Rzn-e, and atom a layer. Such a sv-va are defined as alternatives: one of these in, for example, %Rfs is supposed assumes in Rzn-and availability of atom - number or a line. Alternatives can be set and it is explicit by means of the character '|', for example, the same %Rfs as %Rf|s.

2) Sv-va (1) like atom accompany (nearby on the right) specifying its value of a sv-v, perhaps preceded by their denials '~':

+	- положительное (>0) значение числа
−	- отрицательное (<0) значение числа
0	- 0 типа атома: 0 (%i) или 0.0 (%f) числа, пустые строка и множество св-в
1	- нечетное целое /%i1/,
2	- четное /%i2/

3) Sv-vo %Rl0 Rzn-I define an empty layer.

4) Sv-vo %Vi0 fixes value 0 of the index - an initial node (Rzn-e) of a layer on UKS Vzn-I.

5) Absent a sv-va can implicitly be defined by given: for example, %Rf and %af unambiguously define %Raf. %f sets an alternative - %Af|Raf

P.S. In the last examples not clear is an existence of a layer Rzn-I: it is (%l) or it is absent (% ~ l).

1.3. Storage space

Instead of global variables of the existing programming languages _Space "space" available to all functions as an argument and to transactions in is entered their (item 2), in an initial type is a structure of _Space: () with an empty layer / %R ~ al0/. _Space space layer, as well as a layer on UKS of any Rzn-I can be filled up with nodes - subspaces, including with names indexes, to process them, to delete, etc.
Possibly and movement deep into (on hierarchy levels) spaces, as well as any other layered design, for example by means of the user In function shown to item 3.9 processing (argument) a flow of indexes (integer and/or names indexes) and returning synchronously a flow of Vzn-y of the nodes of structure passed at the same time. In process of passing of In of this way it is possible to process now passable nodes (and not just the last as it is accepted) arbitrarily other function using In as an argument.

1.4. Literals

<Литерал> :: = [<Atom [except a name]>] <Layer>|# [-the Indefinite element]

i.e. generally (existence of a layer) it is a normal layered design according to item 1.1. In case of atom - a name the literal is entered as a primitive argument
      _Lit (<Atom> [<Layer>])
In transactions of an inner pattern of functions (item 2.5) _Lit it is not used because any structure - an operand is a literal.
  The literal is broadcast in the code (item 1.1) of a layered design with selection of the free memory blocks (MB) of DRP under each atom and a layer on all hierarchy levels, returning to the link UKA and UKS (copy) to root node (top level) of structure – Rzn-e/%Ral/. If the literal is atom (without layer), then for lack of its amendments (item 2.5.2.1) it is coded with sv-vy %A (out of DRP).

As well as the literal returns _Space unary (not a flow) - a unique value: atom/%A/or Rzn-e. In attempt to use it instead of a flow it is made out as a flow from one element, including the code of end of a flow - an indefinite element with sv-vy %E.

2. Description of the user function

Here everything changes for 100% in comparison with the original project ("http://tadviser.ru/a/157631") - the uniform structure of the user function is entered:

	<name>:(	Params(<пар-р>{,<пар-р>}[,End(<операции>)]),
		Ins(<вход>{,<вход>}),
		[,Synch(<синхробработка>{,синхробработка>}),]
		[Outs(<выход>{,<выход>})]
	)

The structure of "input", sinkhrobrabotka and "exit" is almost identical:

<Имя>:( <flow source>, <couples-ry of processing>, <processing of a flow>)

as well as the organization described below from interaction.
In a normal call <a name [functions]> (<argument> {, <argument> }) this function arguments (values, expressions) are entered in the following order: in the beginning pairs-ry (parameters) Params, and then Ins inputs as their description.

1) At first unary values of Params pairs ditches (item 2.1) are processed in parallel. A part them in Params are set directly (literal) and in function call are absent, the others undertake from a call and in the presence of transactions are processed by them.

2) Then "processings of flows" of all inputs of Ins where each flow arrives or from the outside (item 2.2.1) - from an argument in function call are in parallel started, or it is generated by own source of Well (item 2.2.2) of "input" and in this case the corresponding argument is absent in function call. The machine cut-you of processing of an ocheredy element of a flow move transaction

      => <name of [receiver]>    (a)

to receivers: or directly on a function exit, or on a sinkhroobrabotka or (asynchronous) processing by section Outs "exit". So these the machine cut - you actually form several flows by the number of the receivers listed by transactions (a).

3) Being in Synch and Outs the receivers working in parallel process elements of flows (2) in process of their receipt from sources. Each sinkhroobrabotka separates (distinguishes) the flows arriving to her from different sources and processes them synchronously - in process of receipt of the next element from each of them and only then processes this set - a train arrived on one element from each source - an input or other sinkhroobrabotka. Similarly (2) sinkhroobrabotka create the flows the machine cut-tov sent by her to the listed (2) receivers including the sinkhroobrabotki.

4) Unlike a sinkhroobrabotka each "exit" Outs processes the next flow element which arrived to it regardless of its source - asynchronously and only upon completion of its processing passes to processing of the following. At the same time the machine cut - you processings can be sent by transaction => only directly to the function exit described by "exit" - the main or the channel.

5) Processing of a flow in (2), (3) and (4) has also identical structure:

<processing of a flow>:: = Begin: <transactions>, Go: <transactions> [End: <transactions>]

6) (Identical) to processing also are uniform its steam-ry:

  All is admissible quantity of elements of a flow, by default All does not limit number of the elements arriving on processing and perhaps actually the flow is limited to its source.

  Sum is original value of a result of processing on a flow, the structure generally randomly set which by default is is indefinite.

  Buf is the size (buffers) in number of the elements waiting for processing. The buffer stores elements for giving them on processing in order of priority of their receipt and is designed to reduce dead times of processing because of suspension of sources of flows at employment of the receiver processing of the next elements. In case of a train this steam-r actually sets the size of buffers for each of sources of flows of trains. In the absence of Buf it is considered equal 0.

Values of these pairs ditches are set obviously by a literal or Params pairs rums the link to it by name:

    <couples-r of processing>:: = <name of couples-ra of processing>: <value>

7) Prior to processing of a flow (trains in case of a sinkhroobrabotka) in 0 system - automatically (not transactions) conducted steam-ry are established:
  a) _N is quantity of the processed elements (trains) of a flow.
  b)<имя [приемника]> - quantity the machine cut-tov, sent to their receiver.

P.S. Let's remind that receivers the processing machine cut-tov inputs of Ins and can have a sinkhroobrabotok a little and all of them are defined from transactions (2a). Outs "exit" receiver one has specific exit of function of the same name, including the main Out which even for lack of explicit definition of his name can be used as pairs-r (b).

8) Prior to processing of a flow (trains in case of a sinkhroobrabotka) the transactions Begin about equal 0 pairs ramies (7) preparing initial data for transactions (9) are started: for example, All and Sum values taking into account Params pairs ditches are specified, a part of variables a, b is transferred to a rank global (the general on a flow Sum is similar) with installation of their ref. values..., z, being usually local - defined and acting again when processing each next element of a flow (train).

9) The transactions Go every time are started again (cycle) for processing of the next element of the flow (a train of elements on names of their sources) arriving (arriving in a train) together with sv-you the created sources of flows. At the same time the current value of a result Sum on a flow is optional adjusted and used. Upon completion of the cycle Go _N automatically increases by 1, and values of local a - z are reset in indefinite, perhaps, with release of DRP occupied by their values.

10) Upon completion of processing (exhaustion) of a flow, exceeding of its extent (quantity of elements) of All value or processing interruption (transaction Go) starts the transactions End creating processing results if, of course the section of End is defined. In the section of End Sum and steam-ry (7) have final values at the time of end or interruption of processing of a flow (trains) in Go and can be processed with transfer of results to receivers similarly (2). Anyway even in the absence of End, execution of operations (interruption) at sources of the processed flow is blocked (flows with trains).

2.1. Description of parameters

Par-r has single value (not a flow) and it is set in a type
    <name>: <value [-a literal]> and then in function call it is passed,
or -
    <name>: [<transactions>] and then the ref. value of pairs-ra from function call is processed by transactions (if they are!). The machine cut t of accomplishment of the last from them is accepted as its final value.
Upon completion of processing of pairs ditch transactions of the section End (if it is), which specify values of pairs ditch are started, approving them among themselves, adjust their values already on their names.
Attention! The name of pairs-ra is unique Not only within the section Params: it cannot be used as names of objects of the sections Ins, Synch and Outs.

2.2. Description of inputs of function

<вход>::= <обрабатывающий поток>|<генерирующий поток>

The input generating a flow is absent among function call arguments because the source of this flow is defined directly in the description (Well) of this input (item 3.2). However unlike pairs ditches the elements of flows arriving on inputs or generated by them are processed in parallel and equally regardless of that as the processed flow forms.

2.2.1. The input processing a flow

<имя входа>:(	[<вид источника потока>,]
	[<пар-ры обработки>,]
	<обработка потока>
)

<вид источник потока> ::= Fun|Chanal|Any

Thus any is accepted by a source of the flow arriving from the outside (function argument): expression (Fun), the channel (Chanal) or any of them (Any) creating a flow. The lack of a type of a source of a flow is equivalent to its determination to Any.

2.2.2. The input generating a flow

<имя входа>:(	Well:<источник потока>,
	[<пар-ры обработки>,]
	[<обработка потока>]
)

The difference from an input of item 2.2.1 is as follows:

2.2.2.1. The source of a flow is defined not by an argument of a call of the described function, and directly here in the description of an input:

1) The atom set directly or value of pairs-ra from Params the number of times specified by All repeats. In case of pairs-ra with value - structure atom can be received by amendments of value of pairs-ra as operand according to item 2.5.2.1, and without its actual change.

2) _N - generates a flow of integer numbers 0, 1, 2...

3) The layered design set directly (literal) or value of Params pairs-ra as space (_Space) or its node (subspace) by means of amendments according to item 2.5.2.1. In this case its bypass on a circuit (from top to down and from left to right) with generation of Vzn-y of the nodes passed at the same time is automatically made.

4) Superposition of the built-in and library functions using as arguments and Params pairs-ry. The only built-in function (primitive) is entered

      Stream (<flow element> {, <flow element> }),

generating in turn from left to right as elements of a flow of value of the arguments.
Even the simplest source of a flow of For (<beginning>, <quantity of elements of a flow>, <step>) is entered as library function with the corresponding description (item 3.1).

2.2.2.2. For lack of "processing of a flow" (Begin, Go and End) the next Well generated by a source the flow element automatically goes

• on a sinkhrobrabotka if she only and contains a name of this input in the Regs list (see item 2.3);
  
• otherwise on the main exit of Out of function.
  
  

In the absence of All the termination (or interruption) a flow together with a source is defined by a source, or automatically at a stop of the receiver of this flow.

2.3. Sinkhroobrabotka

<синхрообработка>::=
<name index>:(	Regs(<источник[потока]>{,<источник>})
	[<пар-ры обработки>,]
	<обработка потока>
)

Features of a sinkhroobrabotka:

1) Her name differs from names of exits (item 2.3) of the section Outs in the absence of which the name Out (the main exit) can be appropriated to one of a sinkhroobrabotok and even to transfer results of processing to this sinkhroobrabotka as to the main exit by transaction => without indication of a name.

2) On processing inputs of Ins or other sinkhroobrabotka (sources) direct to a sinkhroobrabotka elements (flows) to processing by transaction

=> <name of a sinkhroobrabotka>

and for each sinkhroobrabotka specified in this transaction by a name the Regs list of the sources using this transaction consisting Not less than from their two names automatically forms. This list can be adjusted manually.

3) In case of the only sinkhroobrabotka in Synch her name together with the brackets limiting it can be absent (see an example of item 3.5) and then in the absence of Outs => Ins inputs a name the sinkhroobrabotki falls to transactions, but it is meant.

4) Ref. value the machine cut - that the transactions Go is a train element from the source determined in Regs by the first. Names of sources of the Regs list are used in the transactions Go as names of elements of the processed train are operands of transactions.

5) At employment (overflow) selected to a source from Regs of the Buf buffer for the period of processing of a train and release of the buffer this source stops at transaction accomplishment => transfers of an element for the following train of this (!) sinkhroobrabotka.

6) At end of one of the listed Regs of sources (sv-in %E of the termination of a flow), the sinkhroobrabotka in the subsequent trains uses the element (by name a source) received from it by the last.

2.4. Description of exits of Outs

The description and processing of "exit" differs from the "inputs" considered by item 2.2 in the following here:

1) Instead of an input name - an exit name. Following for':' a part of the description of an exit can be absent and then the element which arrived from a flow source without processing goes to the corresponding exit of function - Out or channel.

2) Sources of flows (with transactions => <an exit name>) can be much. Therefore similar to item 2.3 their Regs list forms.

3) The flow arriving on an exit comes to the end with start of the transactions End of an exit after exhaustion of all sources determined by its Regs list.

4) It is possible to replace with the only exit of Out (its description) all section Outs.

5) Determination of Out can be absent and for lack of the only bezimyanny sinkhroobrabotka (item 2.3) transaction => sends the machine cut t of calculations to the main - syntactically the defined function exit.

6) In the presence of exits except Out - channels as their determination they can be renamed in the appeal (call) to function by an additional argument

<имя выхода - канала><имя выхода - канала>_Outs([,])

2.5. Programming of transactions of sections of Begin, Go and End

2.5.1. Structure of transactions of sections of Begin, Go and End

<transactions>:: = [<condition>] <transaction>|[<condition>], <block of transactions>
<block of transactions>:: = (<transactions> {, <transactions> })
<condition>:: = <Sv-va atom> [! <operand>]?|[~]?

Sv-va atom is set directly according to its determination (item 1.2.1, %p), or value of Params pairs-ra or variable a-z and contains required a sv-v (or their denial '~') an operand (to the right of '!'), and in its absence - the machine cut - that the previous transaction. Extremely short condition '?' refers to the successful machine cut t of check of the last condition in the same block of transactions, and' ~?' denies it - an equivalent "Differently (else)" classical languages. Difference from the commonly accepted constructions of If...then...else here that '?' and '~?' it is possible to reuse in the block of transactions.

Exception: In case of the transactions Go of "exit" Outs one more option of a condition is entered:

<flow source name> {|<flow source name> }?,

the element permitting accomplishment of transaction (block) when processing from one of Regs sources listed in a condition.
Transactions (including blocks) are satisfied in turn from left to right at accomplishment conditions or in its absence.
      At the performed first transaction of the section in quality the ref. machine cut - that automatically is accepted:

- for Params pairs-ra its value entered in function call,
- for the section of Begin - ref. Sum,
- for Go - the next processed flow element (the first of Regs for a train),
- for End - Sum value, final after processing of Go.

  <transaction>:: = [<activity code>] [<operand>]
  <operand>:: = <object of processing> {<refining>}|<exit name>

For lack of an activity code the value of an operand is accepted in quality the machine cut - that transactions.
      The activity code defines its essence. Transaction as a rule is executed over the machine cut volume of the previous transaction (not having designation) and an operand.

      Accomplishment of transaction can be interrupted and is normal with preserving its ref. machine cut - that, a popolnyamy sv-v of %X. It is caused by different factors, for example, absence or inadmissible type of an operand, an inadmissible ratio sv-in the ref. machine cut - that and an operand, overflow of DRP, etc. At interruption of transaction the following situations are possible:

1) Execution of operations of the section stops (is interrupted) as well as processing of a flow (Go) if the following transaction does not begin a condition with the analysis of existence or lack of a sv-v of %X.

2) At interruption of transactions of pairs-ra (Params) sv-in %X purchases also steam-r (its value) which will be transferred together with its value by the beginning of the interrupted transaction to the section of End Params. At the same time transactions of other NE pairs ditches are interrupted. Transactions of the section End Params can exclude sv-in %X at pairs ditches (item 2.5.3.1), otherwise accomplishment of function stops as well as in (4)

3) At interruption of transactions of the section of Go and automatically a flow (trains) the section of End of the same part of the description of function (an input, a sinkhroobrabotka or an exit) with sv-vy %X at the ref. machine cut - that processings is started.

4) In case of interruptions of transactions of the section End is interrupted also function accomplishment (stops), on all its exits codes of end of a flow with sv-vy %X in addition to %E form (are transferred to receivers) if the section of End did not eliminate %X property.

5) Sv-vo %X at the ref. machine cut - that can be set transaction (item 2.5.3.1) and by that actually to cause the same reaction (1-4) systems.

2.5.2. Objects of processing

Such objects are:

1) Par-r Params (a name, item 2.1) and the structure determined by it
2) Element of space of _Space (Section 1)
3) Sum result (generally is structure) determined separately by each input, a sinkhroobrabotka and an exit of function which ref. value is defined and specified by the section of Begin
4) Par-ry processings of the section of Go
5) Set of 26 variables of each section defined as a, b..., z
6) A literal - structure

All objects, except variables (5) and literals (6), are global - have sv-vy %G[lobal], i.e. are available when processing all elements of a flow and all sections of Begin, Go and End. Objects (1) and (2) are equally available also in all sections Ins, Synch and Outs.
      Objects (5) are local - are defined separately for each next processed element: become indefinite (%#) at start of transactions of the section of Go, losing former values. At the same time installation of a sv-v of %G (item 2.5.3.1) at any of objects a-z giving them possibilities of an object of Sum in their use is allowed.

2.5.2.1 Refining of an operand

Object of processing as an operand can be followed (on the right) by the sequence of amendments of its elements (atom, a layer, a layer node) participating directly in transaction. Each of amendments can have an appearance:

<refining>:: = the % <[required] a sv-v>|[<the index [a layer node>]
<index of a node of a layer>:: = <whole>|<name index>

In the sequence of the amendments applied to an object each next is applied to the machine cut - that previous and at its reduction to required to sv-you is identical to transaction of item 2.5.3.1 unlike which here properties are set obviously (atom). Refining [<index> of identically similar transaction ' [' with I Rzn-eat (item 2.5.3.3).
      As well as in case of item 2.5.3.1 incorrectness of refining, for example, for lack of a possibility of reduction of an operand to the necessary type, blocks accomplishment of the following of amendments of an operand on the right and interrupts transaction with assignment to initial NE changing at the same time the machine cut - that a sv-v of %X with the corresponding reaction of a system (item 2.5.1).

Example: _Space [SubA%R - selects from a storage space - an object of _Space (Rzn-e) of Vzn-e of a subspace with the name SubA (the 1st refining) and then finally creates (the 2nd refining of %R) Rzn-e (UKA pair with UKS), specified by it I Vzn-eat.

Attention! In the presence of an activity code unlike item 2.5.3.1 of direct object conversion by its amendments NE occurs: in the course of transaction these amendments of an operand happen is hidden (implicitly) and therefore it is more effective both on high-speed performance, and regarding economy of DRP (memory). Otherwise the machine cut t of the last (on the right) of refining becomes a mouth of transaction. Change by transaction (code) of the references UKA and UKS created by amendments or the contents specified by them is not allowed: there is an interruption of transaction with replenishment ref. r - z - that sv-vy %X.

2.5.3. Codes and content of transactions

1) For lack of an activity code the copy of value an operand taking into account its amendments (item 2.5.2.1) is accepted in quality the machine cut - that this "transaction", replacing with it the ref. machine cut t. At the same time, as well as in the transactions changing the sizes of atoms and layers in DRP and unique (not secondary) links (UKA, UKS) to them described further there is a need of release of all or a part of DRP occupied by them or, on the contrary, expansion of this memory at the expense of a free part of DRP.

2) Content of transaction types determine the ref. machine cut - that and/or an operand (taking into account amendments by item 2.5.2.1), defined as

%A is atom,
%Ra ~ l is atom or the link (UKA) to it,
%R ~ al is a layer or the link (UKS) to it,
%R[al] - Rzn-e with excellent from 0 UKA and UKS.
%V - Vzn-e

2.5.3.1. Reduction of data to the type required by properties

This first and most important transaction has a condition appearance without'?' (item 2.5.1) also brings (will transform) an operand or to its absence the ref. machine cut t to required obviously (directly atom of a type %p) set by sv-you to a type (item 1.2). If "condition" is limited to check of compliance sv-in an operand or the machine cut - that required, then here they are given to the type demanded by these sv-you that NE for all ref. values is possible. In the last cases transaction is interrupted (item 2.5.1). In case of reduction of an operand the ref. machine cut t of transaction remains the same.

Admissible conversions:

1) Ref. Vzn-e is replaced (machine cut t) with requirements of its properties on:

%R - the value specified by it,
%Ai is the index,
% [l] ~ i - Rzn-e from UKA=0 and the UKS (%Rl ~ a).

2) Ref. Rzn-e (UKA pair with UKS) can be transformed by requirements sv-in:

%A	- заменено копией атома (вне ДРП), указываемого УКА. При УКА=0 операция прерывается. Это преобразование можно дополнить требованиями (3) изменения типа полученной копии атома.
%~a	- УКА сбрасывается в 0
%~l	- УКС сбрасывается в 0
%~a~l	- выполнение предыдущих %~a и %~l
%Ai	- исх.%R~al заменяется размером слоя по УКС.
%l0	- не пустой слой (%l~0) по УКС сбрасывается до пустого.
%l	- В отсутствие слоя (%R~l) создается пустой слой.
%a0	- сброс атома в 0-е значение его типа.
%V	- меняется на Vзн-е - пару УКС с указываемым УКА индексом - целым (%i) или именем (%n), если, конечно, такой узел в слое по УКС существует (иначе прерывание %X). В отсутствие УКА индекс принимается равным 0.

3) At ref. %A or %Ra it is possible to change atom type, having requested a sv-v with options of required types from which the first admissible is automatically selected:
%s - value of any type will be transformed to its line display (line) according to syntax.
%f - whole (%i) becomes material.
%i - material (%f) will be transformed to whole (%i) with loss of a fractional part, but not the number is replaced with its size according to syntax (length of a name, line, quantity sv-in and their denials).
The % − - changes the sign '+' numbers on '−'.
The % ~ − or % + - changes the sign '− 'on+'.

4) %A0 - reset of ref. atom in 0th value of its type.

5) Ref. %A (atom) can be transformed to Rzn-e by the requirement of %R [a ~ l]. In this case the free block (BP) of memory from DRP in which the copy of ref. atom is located is selected. UKA of this block and UKS=0 form required Rzn-e.

6) Ref. %As (line) upon the demand of %Ral is considered as the syntax image of structure which is broadcast in the code with selection of free memory of DRP under atoms and layers and formation Rzn-I - links UKA and UKS to this structure.

7) Any value (structure) can be brought to atom of a type %Ap supporting a sv-v of original value.

2.5.3.2. Transactions with atoms

1) Transactions '+', '−', '*', '/' are executed with atoms the ref. machine cut - that and an operand, perhaps after its amendments according to item 2.5.2.1, but %A or %Ra ~ is obligatory with sv-you for l. Content of transaction is defined by types of these atoms. The machine cut t of transaction substitutes atom the ref. machine cut - that directly (%A) or in BP (DRP) on its UKA Rzn-I and in this last case of Rzn-e (UKA and UKS) the ref. machine cut - that remains.

</b>-</b> In case of numerical (types of %if) the ref. machine cut - that and an operand is normal arithmetic transactions which results are defined by types of numbers: if they are whole (%i), then and result - an integer number, differently material. Division on 0 causes transaction interruption.

</b>-</b> It is possible to add to date (%d) (+) or to subtract (% −) whole (%i), having received new date. It is possible to subtract from it also date, having received whole in days.
</b>-</b> Transaction' +' for atoms of ref. volume and operand - lines (%s) is treated as a katenation of lines: the line of an operand is finished by the line the machine cut - that.
</b>-</b> Transaction '−' - lines (%s) the machine cut - that deletes the first occurrence of a line (%s) of atom of an operand from atom. The transaction '/' deletes all occurrences.
</b>-</b> Transaction '*' a line (%s) of atom the machine cut - that repeats the number of times specified by operand atom.
</b>-</b> The transaction '/' atom - a line (%s) the ref. machine cut - that reduces (cuts off) removal of its final part to the size specified by an integer number - an operand.

2) Transactions +=, −=, *=, / = differ from (1) those that as object of processing not the ref. machine cut t, but an operand is accepted. The ref. machine cut t which assumed a role of an operand (1) remains.

2.5.3.3. Transactions with R-values

1) [<index> - determination Vzn-I am UKS ref. Rzn-I and the index which value (%i) is set obviously (literal), the a-z variable, Params pairs rums.

2) [<name index> - in a layer on UKS ref. Rzn-I am wanted a node with a name index and his Vzn-e - the transaction machine cut t is defined.

3) The following transactions are executed with a layer Rzn-I with sv-you %R ~ al:
+ - the layer is replenished
      a) the copy Rzn-I (UKA pairs with UKS) the operand set similarly (1)
      b) the quantity of indefinite Rzn-y specified by an operand,
      c) indefinite R-value with the specified operand - a name index.

− - from a layer final nodes - pairs (UKA,UKS) in the quantity specified by an operand are removed.
~ - from a layer the node with the index specified by an operand - whole similarly (1) or a name index is removed.
* - the layer is replenished with the copy of the structure defined I Rzn-eat an operand. At the same time unlike '+' atoms and layers of structure of an operand with selection of free DRP are copied.
/ - in a layer initial nodes (Rzn-I) in the quantity specified by an operand are removed.

Example of input of a subspace with the name index SubA: _Space, +SubA

_Space always returns Rzn-e with UKA=0.
The transaction '+' does not change ref. Rzn-e (UKA and UKS).

4) Transactions +=, −=, ~=, * = and / = differ from (3) those that are made not with a layer the ref. machine cut - that, and an operand layer. Now the ref. machine cut t saving the value by the end of transaction acts as an operand.

2.5.3.4. Transactions with V-values

Let's remind determination Vzn-I (item 1.2) as pair <UKS, Index>, the specifying Rzn-e - a node in a layer on UKS with index (0, 1, 2...), and now with I Vzn-eat transactions:

1) + and −, respectively, add or subtract from the Vzn-I index the machine cut - that value of an operand - type atom whole (%Ai), creating new Vzn-e the machine cut - that. In attempt to set negative value of the index the last automatically is reset in 0. In absence Rzn-I, specified by received Vzn-eat, transaction is interrupted with preserving ref. Vzn-I with sv-vy %X.

2) + = and − = are executed identically (1) with only that difference that the integer value of atom - the machine cut - that is added to the Vzn-I index of an operand and the ref. machine cut t (whole) saves the value.

2.5.3.5. Transfer of values

Earlier transaction => transfer the machine cut - that the transaction preceding it to receivers of this result was already considered (Subparagraphs 2.2, 2.3 and 2.4). Further - still transactions of transfer of values.

1) Transaction <− performs the following operations about the ref. machine cut volume:

- on his Rzn-iya's UKA places the copy of atom of an operand in BP (DRP), deleting the atom from there;
- in his Rzn-iya substitutes UKA or UKS with similar not equal 0 copies of the links Rzn-I of an operand;
- specified by it (I Vzn-eat) with Rzn-e Rzn-I substitute with the copy (copies of UKA and UKS) an operand.

2) −> - this transaction is similar (1) and differs only in the fact that the machine cut - that is executed not over ref. value, and as value of an operand - as an operand the ref. machine cut t which is not changing at the same time value acts.
Exception: In case of an operand of a-z or Sum without the amendments (item 2.5.2.1) accompanying it the copy the ref. machine cut - that (atom, links) simply substitutes ref. value of an operand.

3) Transaction <> makes exchange of values the ref. machine cut - that and an operand - z

Example: sequence of transactions ABC(10.130, Scheme, 22.77), −>_Space[SubA] substitutes Rzn-e, specified I Vzn-eat subspaces with the name SubA on Rzn-e, created by a literal of ABC (...).

2.5.3.6. Measurement and Comparison of values

These transactions use the mechanism sv-in (item 1.2) of values, considering Sv-va atom as a set sv-in together with their denials (~):

1) & - a product of sets sv-in the machine cut - that and or the operand which is not Sv-va atom (%Ap), or (differently) a set sv-in, provided by value of an operand - atom. At the same time the machine cut t - atom of a type %Ap replaces initial by the beginning of transaction. In transaction of intersection in each of sets an element is separate sv-in together with the code which is optional preceding it '~' its denials.

2) | - union of sets sv-in the ref. machine cut - that and the operand defined similarly (3). At emergence as a result of consolidation (set) at the same time of a sv-v, for example 'a' and its denials' ~ a' both leave from the machine cut - that transactions.

3) The transactions &= and | = are identical (1) and (2), however their machine cut t substitutes not its ref. value, but value of an operand.

4) = - comparison of atoms (%A or %Ra) the ref. machine cut - that and values of an operand (taking into account their amendments according to item 2.5.2.1). As a result of comparison the machine cut t saved by the end of ref. transaction purchases in addition a sv-v:

\	- один из атомов отсутствует или не совпадают их виды
=	- значения атомов совпадают
<	- значение атома рез-та меньше чем у атома операнда
<=	- значение атома рез-та не больше чем у атома операнда
>	- значение атома рез-та больше чем у атома операнда
>=	- значение атома рез-та не меньше чем у атома операнда

At the beginning of transaction listed above a sv-va are removed.

5) <<-in case of atom occurrence (%Aspn or %Raspn) an operand, as substrings, in atom of a similar type the ref. machine cut - that (a line, a name index or a sv-va) as the line, the machine cut t are purchased doponitelno sv-in 'Y', previously (at the beginning of transaction) by deleted.

6)>> - Differs from (5) only in the fact that atom occurrence the machine cut - that as substrings, in operand atom is checked.

7) == - Comparison of UKA Rzn-y or Vzn-y indexes. As a result among sv-in the machine cut - that appears or disappears sv-in '%='.

8) ~ ~ - Similarly (7) comparison of UKS R-or Vzn-y.

Example: ABC (11,22,33,44),-> b, 3, % =b ~ al%i
Whole 3 it is compared here (transaction =) with refining of structure of b (Abc (...)) - % ~ al%i to the size of a layer of this structure equal 4. As a result machine cut t 3 of all sequence of transactions purchases sv-in % <. Once again we will pay attention that at the same time variable value of b with ref. structure remains the same - does not change when refining.

2.5.3.7. Additions to transaction =>

1) Transaction => Go stops execution of operations of Go and the following their cycle on processing of the next element of a flow or a train (sinkhroobrabotka) renews.
2) Transaction => End stops execution of operations of the section of Begin or Go and starts transactions of the section End.

3. Examples of the description of the user functions

3.1. Generator of a flow rise, rise+h, rise+2*h... in number of q

For(	Params(	rise:(%~A|~i~f?0),
		q:(%Ai?%~−,~?1),
		h:(%Aif?(%0?1),~?1)
	),
	Ins(Calc:	(Well:0, All:q, Sum:rise, Go:(Sum,=>, h, +=Sum)))
)

1) Entered by the user of rise pairs-r - not atom / ~ or not numerical / ~ i ~ f/is established by A/in 0 with sv-vy %Af. At integer q the sign '−' is reset if it is. Not the integer value is accepted equal 1 with sv-vy %Ai. It is similarly adjusted pairs-r h with only that addition that its 0th value is replaced with 1 with sv-vy %Af.

2) All implementation of the For function consists of the only input of Calc - the flow generator from 0 (Well: 0). At the same time the ref. Sum value is accepted equal to value of rise pairs-ra (Sum: rise).

3) Having received the next 0 flows of Well Go gives Sum value on an exit of function and then increases (+ =) Sum on h. After exhaustion of All of the cycles Go function successfully comes to the end.

3.2. Generator of a flow bnd1, bnd1+h, bnd1+2*h... to bnd2

While(	Params(	bnd1:(%~A|~i~f?0%A),
		bnd2:(%~A|~i~f?0%A),
		h:%0?1,
		End:(bnd1,=bnd2, %>%−%h, ~?%~−%h)
	),
	Ins(	Sum:bnd1,Go:(Sum,=>,+h,−>Sum,=bnd2,%>?(h,%~−?%X), %<?(h,%−?%X)))
)

1) Unlike the previous generator of a flow here in processing of pairs ditch the transactions End which comparing on value bnd1 and bnd2 are entered set at h step the sign '−' if bnd1> bnd2 and reset it differently.

2) Respectively, control of end of a flow becomes complicated: now Sum + is compared by h to bnd2 taking into account sign h. Anyway interruption of a flow and its processing happens installation of a sv-v %X which is usually set at transaction failure.

3) In the presence of the only input his name is deleted together with the brackets limiting the description of an input.

3.3. Generation of a flow of factorials of natural numbers

Fact (<n> [<couples/odd number>]) – in lack <couples/odd number> (Odd pairs-r) generates a row

1!, 2!, 3!, 4!, …, n! (1, 3, 6, 24, …).

The sign <couples/odd number> (item 1.2) passes on a function exit only, respectively, factorials of even or odd values of their arguments of n=1.2, …. Anyway <n> is quantity of elements of an output flow of the Fact function. The sign <couples/odd number> can be sv-vy %1 (odd number) either %2 (couples) or any number with corresponding sv-vy %1 (odd number) or %2 (couples) according to item 1.2. The lack of these sv-in is equivalent to lack of the second of pairs-ra (its uncertainty).

Description of function:

Fact(	Params(n:(%Ai?%~−,~?0), Odd:(%Ai1|Ai2?%Ap,~?%K)),
	Ins(Well=_N,Sum:1, Go:(+1,−>a,%~K!Odd?(%Ap,=Odd, %=?(Sum,=&gt)),a, *=Sum)),
	Out:(All:n)
)

1) At integer pairs-r n the sign '−' is removed if, of course it is. NOT integer steam-r is reset in 0.

2) The second integer steam-r of Odd is given to a type of %Ap (sv-v) if, of course, it it yet NE is, i.e. becomes the equal to sv-you. Otherwise (not integer steam-r) it is replenished sv-vy %K.

3) Factorials for each future issue _N = 0, 1, 2... the next generated Sum are counted by correction ref. Sum=1 (multiplication by a=_N+1) on condition of equality in a=_N+1 and Odd - both even or odd whole.

4) On issue of n of results (factorials) an exit (All: n) it is closed, and together with it the Well generator: _N of natural numbers also comes to the end function.

3.4. Generator of V-values of nodes of a layer of structure

Description of function:

Glay(	Params(S:(%V?%R, %~R|~l?%X), q:0, End:%~X!S?(S%~a%i!, −>q)),
	Ins(Well=For(0,q,1), Go:(−>i; S[i,=>)),
)

1) An argument (pairs-r S) functions - the structure set by a literal, _Space, expression by means of Vzn-I or Rzn-I. On Vzn-yu it is taken (%R) specified by it Rzn-e. If it is after all not Rzn-e or it is deprived of a layer, pairs-r S purchases sv-in %X for lack of which pairs-r q is defined by the transactions End Params as the size of a layer of structure of S.

2) Unlike item 3.3 here instead of the built-in generator of natural numbers the For function determined earlier (item 3.1) working with Go Ins is used. The only input of Ins is deprived not only a name here, but also brackets. The type of an input is defined by existence of Well.

3.5. Calculation of Exp (x) - exhibitors

The suitable fraction (expression) calculating Exp(x) from chain in 5 cycles has an appearance [6.7]:

^{(1680+840x+180x2+20x3+x4) / (1680−840x+180x2−20x3+x4)}

Description of function:

Exp(	Params(x:%~A|~i~f?%X),
	Ins(	A:(Well:Stream(1680,840,180,20,1), Go :=>),
		B:(Well:x, All:5, Sum:1, Go:(%0!_N?1,~?(x,*=Sum,=>)))
	),
	Synch(	Regs(A,B), Begin:(%GAf0!a,%GAf0!b),
		Go:(A,*B, +=a, %1!_N?−=b,~?+=b),
		End:(a,/b,=>)
	)
)

1) The only steam-r x with the only transaction and therefore the selecting transactions of a bracket are absent (are not obligatory). In case of a sv-v of the argument entered in function call - not Atom/%~ A/or absence sv-in whole and material/%~ i ~ f/of pairs-ru is added to %X, in the absence of the section of End of pairs ditch defiant interruption of function.

2) In the section of Ins two generators of a flow from which one actually built-in A (Stream), and the second B creates a flow of degrees of pairs-ra 'x' of 5 (All) elements, since degree 0 are defined. To both elements of a flow transaction => go to a sinkhroobrabotka (Synch).

3) The section of Begin of a sinkhroobrabotka sets a sv-v of %G [lobal] and at the same time %Af0 - installation in 0.0 variables an and b.

4) The section of Go at the same time counts the amounts of numerator and a denominator of suitable fraction of Exp (see above), respectively, in values of variables an and b and the section of End calculates value of the fraction - Exp and sends (=>) to a function exit.

3.6. Calculation of Sin (X)

Result - the amount of a number of the members of a row found by recurrent formulas [6.7]:

_U1=x, _Uk+1 = ^−x2*Uk / (2k * (2k+1)) for k=1.2...

so far the next member of a row on an absolute value will not reach the set error - value of MS pairs-ra in the following description of function:

Sin(	Params(	x:(%Aif?%f, ~?%X), ms:0.0001, x2:0, End:(x,*x,%−,−>x2)),
	Ins(	Well:_N, Sum:x,
		Begin:(x,−>u,%G!u),
		Go:(+1,*2,−>k,+1,*=k, x2,*u,/k,−>u,+=Sum,?%~−, =ms, %<?=>End),
		End:(Sum,=>)
	)
)

1) Ref. pairs-r x - the argument is entered in a call of Sin (x) of function and %Aif is controlled on compliance to sv-you (it is possible to replace with %Ai|f or %Ai|Af). Par-r ms=0.0001, and x2 is calculated as ^−x2 in the section of End Params.

2) The only input generates (Well: _N) flow 0, 1, 2... and therefore his name is absent.

3) Par-r x does not allow use of variable x. Variable u stores the next member of a number _{of Uk} found on a recurrent formula. Since the beginning of the transactions Go variable k receives value value 2 * (_ N+1) and then 2k * (2k+1) a recurrent formula.

4) Uk is added to the amount of Sum of a row +=Sum).

5) At value of' u' _(Uk) resets the sign '−' (if it is) and the received value is compared (=) with a margin error ms: if it less ms, then the transaction Go stop transaction => End of transition to the section of End sending Sum to a function exit.

3.7. Calculation of Cos (X)

The same recurrent formulas with replacement (2k+1) on (2k-1). Therefore in the section of Go enough transaction 'k is higher (item 3.6), +1' to replace on 'k,-1'.

3.8. Calculation of Tg (x) – a tangent

Here with not smaller than in item 3.5 accuracy achieves result by rather simple suitable fraction:

^{(945 *x − 105*x3 + x5) / (945 − 420*x2 + 15*x4)}

Description of function:

Tg(	Params(x:%~A|~i~f?%X),
	Ins(	A1:(Well:Stream(945,-105,1), Go: =>sh1),
		B1:(Well:1, All:3, Sum:x, Go:(Sum,%~0!_N?(*x,*x,−>Sum),=>sh1)),
		A2:(Well:Stream(945,−420,15), Go: =>sh2),
		B2:(Well:1, All:3, Sum:1, Go:(Sum,%~0!_N?(*x,*x,−>Sum),=>sh2))
	),
	Synch(	sh1:(Regs(A1,B1), Sum:0.0, Go:(A1,*B1, +=Sum), End:(Sum,=>)),
		sh2:(Regs(A2,B2), Sum:0.0, Go:(A2,*B2, +=Sum), End:(Sum,=>)),
		Out:(Regs(sh1,sh2), Go:(sh1, /sh2, =>))
	)
)

Inputs of A1 and A2 generate flows from coefficients, respectively, numerator and a denominator of suitable fraction, and inputs of B1 and B2 are flows from 3 elements, according to odd and even degrees x. As x it is defined as pairs-r (Params) that is NE the variable designated by usually Latin uppercase letter.

      Sinkhroobrabotki of sh1 and sh2, in parallel processing trains from elements from sources, respectively
Regs (A1, B1) and Regs (A2, B2), calculate, respectively, numerator and a denominator as the amounts of Sum on a flow of trains.

      The main difference here from item 3.5 that Out exit is also defined as a sinkhroobrabotka what allows sinkhroobrabotka of sh1 and sh2 in transaction => not to enter obviously her name Out. In a sinkhroobrabotka of Out transaction => means an output of result of the last transaction directly on the main exit of the described function.

3.9. Indexing of a layered design

Description of function:

In(	Params(Struct:(%~R?%X), mInd:100, mDeep:9),
	Ins(	FUN, All:mDeep,
		Begin:(%G!s, Struct,−>s,%~a!s),
		Go:(	−>i,%Ain?(s, %R~l?%l0, i),~?%X,
			%i?(%−?%X, =mInd, %>?%X, s%Ai, =i, %<=?(−i, %− +1, +=s), s[i, =>),
			~?(s,[i,%~X? =>,~?(+i,[i, =>)),
			%R,%~a,−>s
		)
	)
)

Function on the structure determined by the first argument (Rzn-and) on the flow of indexes created by the second argument creates a way - a flow (at the exit) Vzn-y of the corresponding nodes of structure. In the presence of the only input the name of this input together with the brackets limiting its contents (steam-ry and sections) is absent. Since a node - the structure and further for each next index received on the only input function (the transactions Go of an input) performs the following operations:

1) Saves the next index of a flow in variable i.

2) In case of the integer index / %i/</b>or index name/%n/</b>finds out in the next node (variable s) - Rzn-and (for the first in a flow index it is initial structure of Struct) existence of a layer and in its absence (%R ~ l?) creates its empty (%l0). Otherwise - if the next element of a flow - NE the index, is established sv-in %X with interruption of a flow and calculations.

3) In case of the integer index (%i?):

- Presence of the sign at it − or exceeding of the maximum allowed mInd value by it is checked. In both cases the flow and its processing are interrupted (completion of function).
- The size of a layer of a node (sA%i) is compared (=) with value of index i: if it is less or equally (% ~ <) to the index, then increased on 1 difference between them sets number of the indefinite Rzn-y which are filling up a layer in s.
- Vzn-e of a layer element - s [i goes (=>) to an exit (flow) of function.

4) In case of the index name - differently (~?), than the condition (2), to a descent becomes attempt to receive Vzn-e of element s [i with this index. For lack of interruption of this transaction received by Vzn-e, as well as in case of (2) goes to a function exit. Otherwise the layer of s is replenished with indefinite I Vzn-eat with this name index which then similarly (3) goes to a function exit.

Attention! s [is provided to i by two transactions s, here [i at interruption of the second of them the transaction following them in quality the ref. machine cut - that received value s.

5) In Rzn-and, specified received (3) or (4) I Vzn-eat, atom (% ~ a, UKA=0) is removed then it is located in s.

The used literature

1. V.G. Horoshevsky. Reverse engineering of functioning of computers and systems. M, 'Radio and communication', 1987
2. D. Barron. Introduction to programming languages, 'M.Mir', 1980
3. V. Zhirov. Software and design of structures of a computer. 'M.Nauka', 1979
4. K. Futi, N. of Suzuki. Programming languages and circuit engineering of GSI, 'M.Mir', 1988
5. G. Dzhounz. Programming in the OKKAM language. 'M.Mir', 1989
6. E.Madelung. Mathematical apparatus of physics, reference guide. 'Science', 1968, p. 85-87
7. E. Denisova, A. Kucher. Fundamentals of calculus mathematics. IT St. Petersburg university, Mechanics and Optics, 2010, p. 24-25

Reductions and reference designations

БП	- блок (страница) ДРП
ДРП	- Динамически распределяемая память
исх.	- исходный (ое, ая)
пар-р	- параметр
рез-т	- результат
св-в[о,а]	- свойств[о,а]
%Rail	- свойства R, a, i и l
УКА	- указатель БП с атомом
УКС	- указатель БП со слоем
Rзн-е	- R-значение
Vзн-е	- V-значение

See Also

• Method of Yanov of the analysis of closed-loop processes
• Universal Functional Stream computer with parallel computings
• Functional Stream Mashina. Programs, Data and their processing
• Functional stream computer. Primitva of setup, micro programming
• Functional stream computer. Basic functions, program
• Functional Stream computer. User functions