Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://reference.wolfram.com/language/ref/Function.html below:

A pure or anonymous construct—Wolfram Documentation

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technology expertise.

• Data & Computational Intelligence
• Model-Based Design
• Algorithm Development
• Wolfram|Alpha for Business
• Blockchain Technology
• Education Technology
• Quantum Computation

WolframConsulting.com

• See Also
  • Apply
  • Construct
  • CurryApplied
  • ApplyTo
  • CompiledFunction
  • InterpolatingFunction
  • Slot
  • SlotSequence
  • Characters
  • \[Function]
• Related Guides
  • Functional Programming
  • Scoping Constructs
  • Attributes
  • Function Composition & Operator Forms
  • Wolfram Language Syntax
  • Computation with Structured Datasets
  • Language Overview
  • Combinatory Logic
• Workflows
  • Apply a Function to Cells in a Notebook
• Tech Notes
  • Pure Functions
  • Variables in Pure Functions and Rules
  • Some General Notations and Conventions

body& or Function[body]

is a pure (or "anonymous") function. The formal parameters are # (or #1), #2, etc.

x|->body or xbody or Function[x,body]

is a pure function with a single formal parameter x.

{x₁,x₂,…}|->body or {x₁,x₂,…}body or Function[{x₁,x₂,…},body]

is a pure function with a list of formal parameters.

Function[params,body,attrs]

is a pure function that is treated as having attributes attrs for purposes of evaluation.

• When Function[body] or body& is applied to a set of arguments, # (or #1) is replaced by the first argument, #2 by the second, and so on. #0 is replaced by the function itself.
• If there are more arguments supplied than # i in the function, the remaining arguments are ignored. »
• ## stands for the sequence of all arguments supplied. »
• ## n stands for arguments from number n onward. »
• When applied to an association, #name is equivalent to #["name"], and picks out elements in the association.
• In the form #name, the characters in name can be any combination of alphanumeric characters not beginning with digits.
• The character  is entered as |->, fn or \[Function].
• Function is analogous to λ in LISP or formal logic.
• Function has attribute HoldAll. The function body is evaluated only after the formal parameters have been replaced by arguments.
• The named formal parameters x_i in Function[{x₁,…},body] are treated as local, and are renamed x_i$ when necessary to avoid confusion with actual arguments supplied to the function. »
• Function constructs can be nested in any way. Each is treated as a scoping construct, with named inner variables being renamed if necessary. »
• In Function[params, body, attrs], attrs can be a single attribute or a list of attributes. »
• Function[Null,body,attrs] represents a function in which the parameters in body are given using # etc.

Pure function with one parameter:

Pure function with two parameters:

Set to be a pure function:

Use the pure function:

Pick out named arguments from an association:

Map a pure function over a list:

Select with a pure function:

Use a pure function as a predicate:

Create an array from a pure function:

Sort by comparing the second part of each element:

Specify a custom comparison function in FixedPoint:

Specify a custom color function:

Provide a custom distance function:

Derivative of a pure function:

Derivative of Tan:

Solutions of differential equations may be expressed as pure functions:

Difference equations may return pure functions:

#name is effectively a short form of #["name"]:

#name always refers to the association in the first argument:

Extract from an association slot other than the first:

## stands for all arguments:

## n stands for arguments n and onward:

Create a pure function with attribute Listable:

#0 stands for the whole pure function:

A recursive definition for factorial using #0:

Turn a function that takes several arguments into one that takes a list of arguments:

A function that returns a function that multiplies its argument by n:

Preserve arguments in unevaluated form:

#1 uses only the first argument supplied; the rest are ignored:

Not using any arguments results in a constant pure function:

Replacements can be done inside pure functions:

Formal parameters are renamed whenever there is a possibility of confusion:

The names of the parameters do not matter:

However, reusing a name introduces a new scope:

Nested functions take their arguments one at a time:

f[#]& is the same as simply f in the univariate case:

In general, f[##]& is the same as f:

Turn a formula involving a variable into a pure function:

Use a formula in Table:

Use the corresponding pure function in an equivalent Array expression:

Special-purpose function constructs include InterpolatingFunction:

CompiledFunction:

NearestFunction:

LinearSolveFunction:

& binds more loosely than ->, so it usually needs parentheses in rules:

& binds more loosely than ?, so it usually needs parentheses in pattern tests:

Function does not evaluate its body until the function is applied:

Supplying fewer than the required number of arguments generates an error:

Define the recursion operator of recursion theory [more info]:

Use it to define the factorial function:

Newton's formula for finding a zero of a function:

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4