Operator

An operator (not to be confused with operation) is a mapping from one vector space or module to another. Operators are of critical importance to both linear algebra and functional analysis. Important properties of operators include continuity and boundedness.

Important special cases of an operator include:

Functional, which maps a vector space to its underlying field. The space of functionals over a vector space exhibits duality to it, which has numerous applications. Important applications of functionals are the theories of generalized functions, which extends the classical notion of a function and derivative, and calculus of variations, which generalizes the notion of differential to functionals as they are. Both are of great importance to theoretical physics.
Linear operator, which has a number of characteristics that ease its study. Important examples of linear operators are integral and derivative. In finite-dimensional spaces linear operators are often represented by matrices.

Notation

An operator name or operator symbol is a notation which denotes a particular operator. When there is no danger of confusion, an operator name or operator symbol may be referred to more briefly as an "operator". Strictly speaking, however, the operator is a mathematical object and not the syntactic entity which denotes it. The reason for identifying it with its notation is that there are some operators which have come to have standard notations.

Unicode reserves U+2200 to U+22FF for basic "Mathematical Operators," almost all of which is defined in version 1.0 (and thus can be displayed by most internet browsers released since October 1991)^[1]

Simple examples

In linear algebra an "operator" is a linear operator. In analysis an "operator" may be a differential operator, to perform ordinary differentiation, or an integral operator, to perform ordinary integration.

One example of a differential operator is the derivative itself. The corresponding operator name D, when placed before a differentiable function f, indicates that the function is to be differentiated with respect to the variable.

Operators versus functions

The word operator can in principle be applied to any function. However, in practice it is most often applied to functions which operate on mathematical entities of higher complexity than real numbers, such as vectors, random variables, or mathematical expressions. The differential and integral operators, for example, have domains and codomains whose elements are mathematical expressions of indefinite complexity. In contrast, functions with vector-valued domains but scalar ranges are called functionals and forms.

In general, if either the domain or codomain (or both) of a function contains elements significantly more complex than real numbers, that function is referred to as an operator. Conversely, if neither the domain nor the codomain of a function contain elements more complicated than real numbers, that function is likely to be referred to simply as a function. Trigonometric functions such as cosine are examples of the latter case.

Additionally, when functions are used so often that they have evolved faster or easier notations than the generic F(x,y,z,...) form, the resulting special forms are also called operators. Examples include infix operators such as addition "+" and division "/", and postfix operators such as factorial "!". This usage is unrelated to the complexity of the entities involved.

Examples

This section concentrates on illustrating the expressive power of the operator concept in mathematics. Please refer to individual topics pages for further details.

Linear operators

Main article: Linear transformation

The most common kind of operator encountered are linear operators. In talking about linear operators, the operator is signified generally by the letters T or L. Linear operators are those which satisfy the following conditions; take the general operator T, the function acted on under the operator T, written as f(x), and the constant a:

$T(f(x)+g(x)) = T(f(x))+T(g(x))$

$T(af(x)) = aT(f(x))$

Many operators are linear--for example, the differential operator and Laplacian operator.

Linear operators are also known as linear transformations or linear mappings. Many other operators one encounters in mathematics are linear, and linear operators are the most easily studied (Compare with nonlinearity).

Such an example of a linear transformation between vectors in R² is reflection: given a vector x = (x₁, x₂)

Q(x₁, x₂) = (−x₁, x₂)

We can also make sense of linear operators between generalisations of finite-dimensional vector spaces. For example, there is a large body of work dealing with linear operators on Hilbert spaces and on Banach spaces. See also operator algebra.

Probability theory

Main article: Probability theory

Operators are also involved in probability theory, such as expectation, variance, covariance, factorials, etc.

Calculus

Calculus is, essentially, the study of two particular operators: the differential operator D = d/dt, and the indefinite integral operator $\int_0^t$ . These operators are linear, as are many of the operators constructed from them. In more advanced parts of mathematics, these operators are studied as a part of functional analysis.

Differential operator

The differential operator is an operator which is fundamentally used in calculus to denote the action of taking a derivative. Common notations are dy/dx, and y'(x) to denote the derivative of y(x). Here, however, we will use the notation which is closest to the operator notation we have been using; that is, using Df to represent the action of taking the derivative of f.

Integral operators

Given that integration is an operator as well (inverse of differentiation), we have some important operators we can write in terms of integration.

Convolution

Main article: Convolution

The convolution $*\,$ is a mapping from two functions f(t) and g(t) to another function, defined by an integral as follows:

$(f * g)(t) = \int_0^t f(\tau) g(t - \tau) \,d\tau.$

Fourier transform

Main article: Fourier transform

The Fourier transform is used in many areas, not only in mathematics, but in physics and in signal processing, to name a few. It is another integral operator; it is useful mainly because it converts a function on one (temporal) domain to a function on another (frequency) domain, in a way which is effectively invertible. Nothing significant is lost, because there is an inverse transform operator. In the simple case of periodic functions, this result is based on the theorem that any continuous periodic function can be represented as the sum of a series of sine waves and cosine waves:

$f(t) = {a_0 \over 2} + \sum_{n=1}^{\infty}{ a_n \cos ( \omega n t ) + b_n \sin ( \omega n t ) }$

When dealing with general function R → C, the transform takes on an integral form:

$f(t) = {1 \over \sqrt{2 \pi}} \int_{- \infty}^{+ \infty}{g( \omega )e^{ i \omega t } \,d\omega }.$

Laplace transform

Main article: Laplace transform

The Laplace transform is another integral operator and is involved in simplifying the process of solving differential equations.

Given f = f(s), it is defined by:

$F(s) = (\mathcal{L}f)(s) =\int_0^\infty e^{-st} f(t)\,dt.$

Fundamental operators on scalar and vector fields

Main articles: vector calculus, vector field, scalar field, gradient, divergence, and curl

Three operators are key to vector calculus:

Grad (gradient), (with operator symbol ∇) assigns a vector at every point in a scalar field which points in the direction of greatest rate of change of that field and whose norm measures the absolute value of that greatest rate of change.
Div (divergence) is a vector operator which measures a vector field's divergence from or convergence towards a given point.
Curl is a vector operator which measures a vector field's curling (winding around, rotating around) trend about a given point.

Relation to type theory

In type theory, an operator itself is a function, but has an attached type indicating the correct operand, and the kind of function returned. Functions can therefore conversely be considered operators, for which we forget some of the type baggage, leaving just labels for the domain and codomain.

Physics

In physics, an operator often takes on a more specialized meaning than in mathematics. Operators as observables are a key part of the theory of quantum mechanics. In that context operator often means a linear transformation from a Hilbert space to another, or (more abstractly) an element of a C*-algebra.

Computer programming languages

In general, the term 'operator' in computer programming languages has a different meaning from its use in mathematics. Except in APL and its derivatives, the term 'operator' refers to any function or keyword whose name is a symbol or series of symbols. In most functional languages, the mathematical notion of operators is meaningless, since they do not distinguish between values and functions.

Operators as primitives

In the many of the most common programming languages, even the operators which are functions are a special primitive part of the language, both syntactically and in terms of functionality. For example, most languages provide a '+' (addition) operator, which adds two numbers without making a function call.

There is no standard treatment of operators. For example, in C (and many derivatives such as Java), the arithmetic operators can act on any numeric data type and cannot be defined for any others. In C++, operator overloading allows operators to be defined as functions, albeit only for data types that are not built-in. In Haskell, any non-reserved sequence of symbols is a valid function name and may be given arbitrary precedence and associativity. Lisps do not syntactically distinguish between functions and operators: in a typical Lisp dialect, the binding of the leftmost symbol of a compound expression indicates what kind of expression it is, and thus how its meaning is derived. The symbol may be a function, in which case the remaining elements of the form are treated as expressions to be evaluated to form arguments, or the symbol may be either a built-in special operator, or a user-defined macro operator, in which cases the arguments are subject to arbitrary rules. The term operator is used when it doesn't matter whether it is a macro or built-in, which is often the case. Other languages (primarily older ones) do not have functions which return values at all. However, they often still have operators which do return values, widening the distinction between operators and functions.

Non-mathematical operators

Programming languages often feature non-mathematical operators. These may include operators which reference or dereference pointers, which access array elements, or get the size of a data type. They may also include compound operators such as "+=", which increments a variable by a given value.

Increment operator

In JavaScript, the increment unary operator works like the following:

x++

Where the decrement operator is:

x--

In addition, the increment operator can be written both as x++ and ++x, with separate meanings. For example:

 var y = ++x

is known as preincrement, shorthand for:

 x = x+1
 var y = x

however,

var y = x++

is known as postincrement, shorthand for:

 var y = x
 x = x+1

--x (predecrement) instead of x-- (postdecrement) follows similar behavior.

Some languages, such as C and C++, do not specify when the increment occurs, whether immediately before (or after) use, at the beginning (or end) of the statement, or at some point in between. For this reason, referencing a variable more than once in a statement where the increment operator is used results in undefined behavior. The same code may produce different results on different compilers, different architectures, or even the same compiler with different optimization settings. For example,

int x = 00001
x = x++

may result in x having either the value 0 or 1. Similarly,

int x = 0
int y = x++ + x++

may result in y having either the value 0 or 1 or even 2.

In C++, the nested increment operator is allowed but for only pre-increment and it is not applicable for the decrement operator.

         Ex: int x = 0;
             ++(++x); is allowed but (x++)++, --(--x) or (x--)-- are not possible.

Assembly language

In assembly language programming, the term "operator" refers to the opcode of a given instruction.

References

↑ [1] Unicode Block Names