Previous: , Up: Top   [Contents][Index]


Concept Index

Jump to:   A   B   C   D   E   F   H   I   K   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

A
action choice state: Event History Example
action choice state: Event History N-gram
action choice state, condition for: Structures for Accessing Storage
action emission matrix: Dumping an Action Emission Matrix
actor: Building Blocks for Intelligent Machines
actor: Adaptive Probabilistic Mapping
actor pair: Creating the Model Instance
actor pair handle: Creating the Model Instance
actor temperature: Customizing the Relative Probability Function
actor, large: Small and Large Actors
actor, small: Small and Large Actors
actual number of output signals: Other Parameters of an Actor
adaptive probabilistic mapping: Building Blocks for Intelligent Machines
adaptive probabilistic mapping: Adaptive Probabilistic Mapping
array of probabilities: Getting Output Probabilities Arrays
assembler instruction: Assembler Program Syntax
assembler instruction: Assembler Instructions
assembler program: Assembler Program Syntax
assembler program section: Assembler Program Syntax
assembler program section, data: Variables in an Assembler Program
assembler program section, data: Defining Probabilities Lists
assembler program, parsing: Parsing an Assembler Program
assembler program, preprocessing: Using the Assembler Preprocessor
assembling a node: Loading a Parsed Program into a Node
automatic spur: Automatic Spur
auxiliary probability variable: Auxiliary Variables

B
behavior mode: Controlling Random Behavior of an Actor
behavior mode: Controlling Random Behavior of a Multinode Model
binary instruction parameters: Instruction Meta-class Event Handling
built-in instruction: Assembler Instructions

C
callback function, enumeration: Event History N-gram
callback function, enumeration: Enumerating States and Cycle Types
callback function, enumeration: Enumerating Entities
calling a node: Multinode Model
calling a node: Transferring Control Between Nodes
cloning the probability profile: Cloning the Probability Profile
cloning the probability profile: Memory Efficient Cloning the Probability Profile
complexity of choice: Animate Machines
condition for an action choice state: Structures for Accessing Storage
continuous time: Incrementing Time
control, possessing by a node: Multinode Model
control, returning from a node: Transferring Control Between Nodes
control, transferring to a node: Multinode Model
control, transferring to a node: Transferring Control Between Nodes
controlled probability variable: Controlled Variables
cycle period, discrete: Customizing the Relative Probability Function
cycle type: Customizing the Relative Probability Function
cycle type, statistics for: Structures for Accessing Storage

D
data section of assembler program: Variables in an Assembler Program
data section of assembler program: Defining Probabilities Lists
defining a probabilities list: Defining Probabilities Lists
defining a probability variable: Variables in an Assembler Program
diassembling a node: Disassembling a Node
direction of signal: Creating an Actor
discrete cycle period: Customizing the Relative Probability Function
discrete time: Incrementing Time

E
entity identifier: Enumerating Entities
entity type: Enumerating Entities
enumeration callback function: Event History N-gram
enumeration callback function: Enumerating States and Cycle Types
enumeration callback function: Enumerating Entities
environment state identification engine: Principle of Operation
error handler function: Error Handling for a Multinode Model
error handler function: Error Handling for the Side API
event handler, instruction class set: Instruction Class Set Function Declaration
event handler, instruction class set: Registering the Instruction Class Set Function
event handler, instruction class set: Instruction Class Set Function Layout
event handler, instruction meta-class: Instruction Meta-class Function Declaration
event handler, instruction meta-class: Registering the Instruction Meta-class Function
event handler, instruction meta-class: Instruction Meta-class Function Layout
event history: Adaptive Probabilistic Mapping
event history: Event History Example
event type, instruction class set: Instruction Class Set Event Handling
event type, instruction meta-class: Instruction Meta-class Event Handling
excitatory (positive) spur: Automatic Spur
execution of a node: Multinode Model
execution of a node: Transferring Control Between Nodes
execution of model: Creating the Model Instance
execution of model: Transferring Control Between Nodes

F
flat storage: Types of Storage
function, enumeration callback: Event History N-gram
function, enumeration callback: Enumerating States and Cycle Types
function, enumeration callback: Enumerating Entities
function, error handler: Error Handling for a Multinode Model
function, error handler: Error Handling for the Side API
function, event handler: Instruction Meta-class Function Declaration
function, event handler: Instruction Class Set Function Declaration
function, key comparison: Creating Maps and Iterators
function, proxy: Custom Random Number Generators
function, storage redirection: Providing Initial Statistics

H
handle: Object Handles
handle of actor pair: Creating the Model Instance
handle of instruction: Basic Datatypes
handle of iterator: Creating Maps and Iterators
handle of map: Creating Maps and Iterators
handle of message: Creating Messages
handle of message list: Creating a Message List
handle of model: Creating a Multinode Model
handle of program: Basic Datatypes
handle of random number generator: Creating a Random Number Generator
handle of side: Registering Interaction Sides
handle of storage: Types of Storage
handle of vector: Ordinary and Sparse Vectors

I
incrementing spur: Incrementing Spur
incrementing spur: Incrementing Time and Spur
incrementing time: Incrementing Time
incrementing time: Incrementing Time and Spur
inhibitory (negative) spur: Automatic Spur
instance of a model: Creating the Model Instance
instruction: Assembler Program Syntax
instruction: Assembler Instructions
instruction class: Principle of Operation
instruction class set: Multinode Model
instruction class set: Principle of Operation
instruction class set: Instruction Class Set Definition
instruction class weight: Setting Instruction Classes Weights
instruction emitting engine: Principle of Operation
instruction handle: Basic Datatypes
instruction instance: Principle of Operation
instruction invocation: Handling Instruction Invocation
instruction meta-class: Principle of Operation
instruction meta-class: Instruction Meta-class Definition
instruction outcome: Principle of Operation
instruction outcome: Setting the Number of Instruction Outcomes
instruction outcome: Handling Instruction Invocation
instruction parameters: Instruction Meta-class Event Handling
instruction parameters, normalization: Setting the Instruction Parameters String
instruction, built-in: Assembler Instructions
instruction, mixed type: Assembler Instructions
instruction, user: Assembler Instructions
instruction, user: User Instructions
intelligence: What Is Intelligence?
interaction side: Registering Interaction Sides
internal state of an actor: Automatic Spur
iterator handle: Creating Maps and Iterators

K
key comparison function: Creating Maps and Iterators

L
large actor: Small and Large Actors
loading a probability profile into a node: Loading a Parsed Program into a Node
look-ahead signal: Setting Look-ahead Signals

M
map handle: Creating Maps and Iterators
map storage: Types of Storage
mapping, probabilistic: Building Blocks for Intelligent Machines
matrix, action emission: Dumping an Action Emission Matrix
matrix, state transition: Dumping a State Transition Matrix
mean number of output signals: Other Parameters of an Actor
message handle: Creating Messages
message list handle: Creating a Message List
mixed type instruction: Assembler Instructions
mode of behavior: Controlling Random Behavior of an Actor
mode of behavior: Controlling Random Behavior of a Multinode Model
model execution: Creating the Model Instance
model execution: Transferring Control Between Nodes
model handle: Creating a Multinode Model
model instance: Creating the Model Instance
multinode model: Building Blocks for Intelligent Machines
multinode model: Multinode Model

N
name of state: stt Instruction
name of state: Loading a Parsed Program into a Node
node: Building Blocks for Intelligent Machines
node: Multinode Model
node class, instruction class set: Multinode Model
node class, instruction class set: Instruction Class Set Definition
node execution: Multinode Model
node execution: Transferring Control Between Nodes
node, assembling: Loading a Parsed Program into a Node
node, calling: Multinode Model
node, calling: Transferring Control Between Nodes
node, creating: Creating Nodes
node, destroying: Creating Nodes
node, disassembling: Disassembling a Node
node, loading a probability profile into: Loading a Parsed Program into a Node
node, possessing control: Multinode Model
node, returning control from: Transferring Control Between Nodes
node, transferring control to: Multinode Model
node, transferring control to: Transferring Control Between Nodes
node, unloading a probability profile from: Unloading the Probability Profile
nonoptimal behavior mode: Controlling Random Behavior of an Actor
nonoptimal behavior mode: Controlling Random Behavior of a Multinode Model
normalization of instruction parameters: Setting the Instruction Parameters String
normalization of probabilities list: Specifying Weights of Output Signals
number of output signals, actual: Other Parameters of an Actor
number of output signals, mean: Other Parameters of an Actor

O
optimal behavior mode: Controlling Random Behavior of an Actor
optimal behavior mode: Controlling Random Behavior of a Multinode Model
outcome of instruction: Principle of Operation
outcome of instruction: Setting the Number of Instruction Outcomes
outcome of instruction: Handling Instruction Invocation
output probabilities array: Getting Output Probabilities Arrays
output probability variable: Output Variables
output signal: Adaptive Probabilistic Mapping
output signals, permutation: Specifying Weights of Output Signals

P
parameters of instruction: Instruction Meta-class Event Handling
parameters of instruction, normalization: Setting the Instruction Parameters String
parsing an assembler program: Parsing an Assembler Program
perception of spur, the way of: Customizing the Relative Probability Function
permutation of output signals: Specifying Weights of Output Signals
pool of permutations of output signals: Specifying Weights of Output Signals
pool of probabilities lists in normal form: Specifying Weights of Output Signals
possessing control by a node: Multinode Model
preprocessing an assembler program: Using the Assembler Preprocessor
probabilistic mapping: Building Blocks for Intelligent Machines
probabilities array, output: Getting Output Probabilities Arrays
probabilities list in an assembler program: Using Probabilities Lists
probabilities list, defining: Defining Probabilities Lists
probabilities list, normalization: Specifying Weights of Output Signals
probability profile, cloning: Cloning the Probability Profile
probability profile, cloning: Memory Efficient Cloning the Probability Profile
probability profile, loading into a node: Loading a Parsed Program into a Node
probability profile, preloaded: Specifying Weights of Output Signals
probability profile, unloading from a node: Unloading the Probability Profile
probability variable: Using Probability Variables
probability variable, auxiliary: Auxiliary Variables
probability variable, controlled: Controlled Variables
probability variable, defining: Variables in an Assembler Program
probability variable, output: Output Variables
program handle: Basic Datatypes
program, assembler: Assembler Program Syntax
proxy function: Custom Random Number Generators
pseudorandom number generator: Random Number Generators

R
random number generator: Random Number Generators
relative probability function: Customizing the Relative Probability Function
returning control from a node: Transferring Control Between Nodes

S
section of assembler program: Assembler Program Syntax
section of assembler program, data: Variables in an Assembler Program
section of assembler program, data: Defining Probabilities Lists
Side API: Exchanging Data Packets in a Multithreaded Program
side handle: Registering Interaction Sides
signal: Basic Datatypes and Macros
signal direction: Creating an Actor
signal weight: Specifying Weights of Output Signals
signal, look-ahead: Setting Look-ahead Signals
signal, output: Adaptive Probabilistic Mapping
small actor: Small and Large Actors
spur: Spur-driven Behavior
spur perception, the way of: Customizing the Relative Probability Function
spur scheme: Adaptive Probabilistic Mapping
spur type: Spur-driven Behavior
spur weight: Customizing the Relative Probability Function
spur, automatic: Automatic Spur
spur, excitatory (positive): Automatic Spur
spur, incrementing: Incrementing Spur
spur, incrementing: Incrementing Time and Spur
spur, inhibitory (negative): Automatic Spur
stack, system: Working with System and User Stacks
stack, user: Working with System and User Stacks
state: Building Blocks for Intelligent Machines
state model: Introduction
state name: stt Instruction
state name: Loading a Parsed Program into a Node
state submodel: Building Blocks for Intelligent Machines
state transition matrix: Dumping a State Transition Matrix
statistics for a cycle type: Structures for Accessing Storage
STL map template: The Implementation of Functionality of STL map Template
storage handle: Types of Storage
storage of flat type: Types of Storage
storage of map type: Types of Storage
storage redirection: Statistics Storage
storage redirection function: Providing Initial Statistics
storage type: Types of Storage
system stack: Working with System and User Stacks

T
temperature of actor: Customizing the Relative Probability Function
terminating model execution: Transferring Control Between Nodes
text instruction parameters: Instruction Meta-class Event Handling
text instruction parameters: Setting the Instruction Parameters String
time of continuous type: Incrementing Time
time of discrete type: Incrementing Time
time, incrementing: Incrementing Time
time, incrementing: Incrementing Time and Spur
trace log: Tracing Model Execution
trace log: Tracing Exchange of Data Packets
transferring control to a node: Multinode Model
transferring control to a node: Transferring Control Between Nodes
type of cycle: Customizing the Relative Probability Function
type of entity: Enumerating Entities
type of spur: Spur-driven Behavior
type of storage: Types of Storage
type of time: Incrementing Time

U
unloading a probability profile from a node: Unloading the Probability Profile
user instruction: Assembler Instructions
user instruction: User Instructions
user stack: Working with System and User Stacks

V
variable, probability: Using Probability Variables
vector handle: Ordinary and Sparse Vectors

W
weight for spur type: Customizing the Relative Probability Function
weight of instruction class: Setting Instruction Classes Weights
weight of signal: Specifying Weights of Output Signals
window associated with an actor: Event History N-gram

Jump to:   A   B   C   D   E   F   H   I   K   L   M   N   O   P   R   S   T   U   V   W  

Previous: , Up: Top   [Contents][Index]