Accueil » Manuel de l'utilisateur

La page suivante décrit les expressions qui peuvent être utilisées dans l'application Wallet. Elle fournit des liens sur la manière de les utiliser et des exemples.

Introduction

Une expression est une chaîne de caractères qui est évaluée pour obtenir une valeur. La valeur peut être un nombre, une chaîne, un booléen ou un ensemble de valeurs. Les expressions peuvent être utilisées dans différents contextes :

Dans ce contexte, les expressions fonctionnent de la même manière que les formules Excel. Elles peuvent contenir des constantes, des opérateurs, des fonctions et des variables. Les sections suivantes décrivent les fonctions et les variables disponibles.

Dans la plupart des cas, une expression appelle une fonction enregistrée, mais il peut également s'agir d'une constante ou d'une variable. Vous pouvez écrire diverses expressions mathématiques, mais il est important de tenir compte de la priorité des opérateurs. Voici quelques exemples simples :

1+1 == 2
2*3 == 6
2**3 == 8
2**3+1 == 9
(5/4)**3 == 1.953125

MIN(1, 2, 3) == 1
MAX(1, 2, 3) == 3

# ...

Vous pouvez également utiliser @file_path pour charger une expression à partir d'un fichier et la faire évaluer. Voici quelques exemples :

@C:/Users/John/Documents/expression.expr

Il s'agit donc d'un moyen simple d'éditer et de réutiliser des expressions en dehors de la console d'application. De cette manière, vous pouvez également utiliser votre éditeur de texte préféré pour modifier les expressions.

Table des matières

Base

Constantes

Les constantes suivantes sont disponibles :

Il suffit d'écrire le nom de la constante dans l'expression. Par exemple, il suffit d'écrire le nom de la constante dans l'expression :

PI == 3.141592653589793
(PI*2 == TWOPI) == true
true != false
1/0 == inf

Commentaires

Vous pouvez écrire des commentaires dans les expressions. Un commentaire commence par un # et se termine à la fin de la ligne. Un commentaire commence par un # et se termine à la fin de la ligne :

# This is a comment
1+1 == 2 # This is also a comment

Vous pouvez également utiliser la syntaxe de commentaire //, mais celle-ci n'est supportée qu'en début de ligne. En voici un exemple :

// This is a comment
1+1 == 2

Notez également que pour des raisons techniques, une expression ne doit pas se terminer par un commentaire. Par exemple, l'expression suivante n'est pas valide :

1+1 == 2

#TODO: Fix this

En effet, un commentaire fonctionne comme une virgule dans une expression, de sorte que terminer par un commentaire revient à terminer par une virgule. L'expression n'est donc pas valide car elle équivaut à une écriture :

5+6,

Virgules

Les virgules sont utilisées pour séparer les valeurs d'un ensemble. Un saut de ligne fonctionne comme une virgule. L'expression est donc invalide car elle équivaut à écrire: :

5+6
7+8

Est équivalent à :

5+6, 7+8

qui renvoie l'ensemble des valeurs :

[11, 15]

Ensembles

Les expressions peuvent être utilisées pour créer des ensembles de valeurs. Un ensemble est une liste de valeurs séparées par des virgules et placées entre crochets. Par exemple, la plupart des fonctions consomment des ensembles de valeurs :

[1, 2, 3] == [1, 2, 3]
[1, 2, 3] != [1, 2, 4]

La plupart des fonctions consomment des ensembles de valeurs. Par exemple : La plupart des fonctions consomment des ensembles de valeurs :

# The SUM(...) function returns a number
SUM([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 55

# The COUNT(...) function returns a number
COUNT([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 10

# Repeat 1 ten times and sum the values
# REPEAT is a function that returns a set of values
# SUM is a function that consumes a set of values
SUM(REPEAT(1, 10)) == 10

Certaines fonctions, telles que MAP(...) et FILTER(...), renvoient également des ensembles de valeurs.

Variables

Vous pouvez définir des variables dans les expressions. Une variable est un nom qui commence par le signe du dollar $. Par exemple :

$name = "John"
$age = 30

$result = "My name is " + $name + " and I am " + $age + " years old."

Les variables sont toujours définies globalement. Cela signifie qu'elles sont disponibles dans toutes les expressions. Par exemple : Les variables sont toujours définies de manière globale :

$a = 55

# The variable $a is available in the following expression
$b = $a + 10

Plus tard, à moins que la variable ne soit redéfinie, elle sera toujours disponible :

# The variable $a is still available
$c = $a + 20

Important : il convient de noter que les ensembles stockés dans les variables sont désalloués une fois l'évaluation terminée. Ils ne peuvent donc pas être utilisés dans d'autres sessions d'évaluation d'expressions.

Macros

Il est également important de noter que $1, $2, $3, etc. sont généralement réservés dans les fonctions. Vous ne devez donc pas les utiliser comme noms de variables globales. Le système attribue généralement des valeurs à ces variables lors de l'appel de fonctions internes. Par exemple, dans la fonction MAP(...), la variable $1 se voit attribuer la valeur de l'élément courant de l'ensemble en cours d'itération. L'exemple suivant l'illustre :

# Sets some values
$values = [1, 2, 3, 4, 5]

# For each value in the set, multiply it by 2
# The $1 variable is assigned the value of the current item in the set
$multiplied = MAP($values, $1 * 2)

# The result is [2, 4, 6, 8, 10]
$multiplied == [2, 4, 6, 8, 10]

Si l'ensemble d'entrée de MAP(...) est un ensemble d'ensembles, la variable $1 sera assignée au premier élément de l'ensemble interne. La variable $2 sera affectée au deuxième élément de l'ensemble intérieur, et ainsi de suite. L'exemple suivant illustre ce principe :

# Sets some values [name, age]
$values = [['Marco', 30], ['John', 40], ['Mary', 50]]

# For each value in the set, combine the name and age to form a phrase like "Marco is 30 years old"
$phrases = MAP($values, $1 + " is " + $2 + " years old")

# The result is ["Marco is 30 years old", "John is 40 years old", "Mary is 50 years old"]
$phrases == ["Marco is 30 years old", "John is 40 years old", "Mary is 50 years old"]

Fonctions macro

Les variables peuvent être utilisées pour stocker des valeurs, mais elles peuvent également être utilisées pour stocker des fonctions. Par exemple, lorsque vous invoquez une

# Define a function that returns the sum of two numbers
# Each arguments can be accessed using the $1, $2, $3, etc. variables
$(a, $1 + $2)

# Call the function
$result = a(1, 2)

# The result is 3
$result == 3

Lorsque vous invoquez une, chaque argument est assigné aux variables $1, $2, $3, etc. La fonction peut donc accéder aux arguments à l'aide de ces variables.

Objets

Les objets sont des ensembles de paires [[clé, valeur], ...]. Les clés sont généralement des constantes de type chaîne de caractères et les valeurs peuvent être n'importe quelle expression. Étant donné que ce langage d'expression n'utilise que des ensembles, les objets sont représentés comme des ensembles de paires clé/valeur. Par exemple, les objets sont représentés comme des ensembles de paires clé/valeur :

# Map the values to an object, i.e. {name: 'Marco', age: 30}
$object = [['name', 'Marco'], ['age', 30]]

Fonctions de base

La base est couverte ! Passons maintenant aux choses sérieuses. Les sections suivantes décrivent les fonctions de base disponibles dans le langage d'expression.

MIN(ensemble, ...)

La fonction MIN(...) est utilisée pour obtenir la valeur minimale d'un ensemble. Le premier argument est l'ensemble de valeurs. Pour plus de commodité, vous pouvez également passer plusieurs arguments au lieu d'un ensemble. Les exemples suivants illustrent l'utilisation de la fonction MIN(...) :

Exemples

# Get the minimum value in a set
MIN([1, 2, 3, 4, 5]) == 1

# Get the minimum value for all the arguments
MIN(1, 2, 3, 4, 5) == 1

# Get the minimum value with all set arguments
MIN([1, -2, 3], [4, 5, 6]) == -2

Rappelez-vous que vous pouvez passer n'importe quelle expression comme argument. Par exemple :

$(fun, RAND(1, 100))
MIN(REPEAT(fun(), 10))

Renverra la valeur minimale de 10 nombres aléatoires compris entre 1 et 100.

Cas d'utilisation : MIN($holders)

Étant donné VTNR.US, imaginons que nous voulions trouver le nom du détenteur ayant le moins d'actions totales. Nous pouvons le faire en utilisant la fonction MIN(...). L'expression suivante renverra le nom du détenteur ayant le moins d'actions :

$symbol = "VTNR.US"

# Get all institutional holders
$holders = F($symbol, "Holders.Institutions")

# Since the data is mapped as an object array "0": {...}, "1": {...}, etc.
# We need to convert it to a set of values by indexing each object by its key
$holders = MAP($holders, [INDEX($2, 'name'), INDEX($2, 'totalShares')])

# Now we should have something like this: [[State Street Corporation, 12.0769], [BlackRock Inc, 5.1746], [Vanguard Group Inc, 4.8573], ...]
MIN($holders)
Cet exemple utilise des fonctions non couvertes, mais il s'agit simplement d'illustrer l'utilisation de MIN(...) dans un scénario réel. Vous pouvez en apprendre davantage sur ces fonctions ci-dessous : - F(...) - Extrait les données fondamentales d'un symbole boursier.
- MAP(...) - Met en correspondance un ensemble de valeurs avec un autre ensemble de valeurs.
- INDEX(...) - Obtenir la valeur d'une clé dans un ensemble.

Le résultat est ["State Street Corporation", 12.0769] au 2023-05-25.

Comment MIN(...) sait-il comparer le deuxième élément de l'ensemble ? C'est parce que chaque ensemble peut avoir un index défini pour être la valeur de comparaison par défaut. Dans ce cas, lorsque la fonction MAP(...) est appelée, le second argument est un ensemble de deux éléments. Le premier élément est le nom du détenteur et le second est le nombre total d'actions. Les fonctions MAP considèrent donc généralement la dernière valeur d'un ensemble comme la valeur de comparaison par défaut. Dans ce cas, la fonction MIN(...) comparera le nombre total d'actions.

Important : toutes les fonctions n'utilisent pas la dernière valeur d'un ensemble comme valeur de comparaison par défaut. En cas de doute, vérifiez la documentation de la fonction ou définissez le premier argument comme valeur de comparaison par défaut. Par exemple, nous pourrions faire correspondre les valeurs comme suit [INDEX($2, 'totalShares'), INDEX($2, 'name')] en inversant l'ordre des valeurs. La fonction MIN(...) compare alors le nombre total d'actions.

MAX(ensemble, ...)

La fonction MAX(...) est utilisée pour obtenir la valeur maximale d'un ensemble. Le premier argument est l'ensemble de valeurs. Pour plus de commodité, vous pouvez également passer plusieurs arguments au lieu d'un ensemble. Les exemples suivants illustrent l'utilisation de la fonction MAX(...) :

Exemples

$values = [1, 2, 3, 4, 5]

# Get the min/max range of values
$minmax = [MIN($values), MAX($values)]

# The result is [1, 5]
$minmax == [1, 5]

Cas d'utilisation : MAX($insider_transactions)

Étant donné les États-Unis, trouvons la plus grande transaction d'initié. Nous pouvons le faire en utilisant la fonction MAX(...). L'expression suivante renvoie l'opération d'initié la plus importante :

Fonctions non couvertes :

# Symbol to use
$symbol = "U.US"

# Lets get the insider transactions data
$insider_transactions = F($symbol, "InsiderTransactions")

# Map the data so we have the name and the value of the transaction
$insider_transactions = MAP($insider_transactions, [
    INDEX($2, 'transactionDate'), 
    INDEX($2, 'ownerName'), 
    INDEX($2, 'transactionAmount') * INDEX($2, 'transactionPrice')])

MAX($insider_transactions)

Vous obtiendrez quelque chose comme ceci [2023-03-31, Tomer Bar-Zeev, 2.4255e+06] à partir de 2023-05-25.

SUM(ensemble, ...)

La fonction SUM(...) est utilisée pour obtenir la somme des valeurs d'un ensemble. Le premier argument est l'ensemble de valeurs. Pour plus de commodité, vous pouvez également passer plusieurs arguments au lieu d'un ensemble. Les exemples suivants illustrent l'utilisation de la fonction SUM(...):

Exemples

# Get the sum of values in a set
SUM([1, 2, 3, 4, 5]) == SUM(1, 2, 3, 4, 5) == 15

Les valeurs non valides sont généralement ignorées. Par exemple, les valeurs non valides sont généralement ignorées :

# nan is not a valid number and will be ignored
SUM([1, 2, 3, nan, 5]) == 11

Cas d'utilisation : SUM($dividendes)

Imaginons que nous voulions faire la somme de tous les dividendes versés chaque année pour MSFT.US. Nous pouvons le faire en utilisant la fonction SUM(...). L'expression suivante renverra la somme de tous les dividendes payés par tous les détenteurs :

Fonctions découvertes :

# Symbol to use
$symbol = "MSFT.US"

# Lets get the number of dividends paid by each year
$dividends = MAP(F($symbol, "SplitsDividends.NumberDividendsByYear"), INDEX($2, 'Count'))

# Sum all the dividends
SUM($dividends)

Au 2023-05-25, le résultat est d'environ 78.

AVG(ensemble, ...)

La fonction AVG(...) est utilisée pour obtenir la moyenne des valeurs d'un ensemble. Le premier argument est l'ensemble de valeurs. Pour plus de commodité, vous pouvez également passer plusieurs arguments au lieu d'un ensemble. Les exemples suivants illustrent l'utilisation de la fonction AVG(...):

Exemples

# Get the average of values in a set
AVG([1, 2, 3, 4, 5]) == AVG(1, 2, 3, 4, 5) == 3

Cas d'utilisation : ROUND(AVG($ages))

Imaginons que nous voulions obtenir l'âge moyen de tous les agents de ZM.US. Nous pouvons le faire en utilisant la fonction AVG(...). L'expression suivante renverra l'âge moyen de tous les officiers :

Fonctions référencées Description de la fonction
F(...) Extrait les données fondamentales d'un symbole boursier.
MAP(...) Établit une correspondance entre un ensemble de valeurs et un autre ensemble de valeurs.
FILTER(...) Filtre un ensemble de valeurs par une expression.
INDEX(...) Obtenir la valeur d'une clé dans un ensemble.
YEAR(...) Obtenir l'année d'une date.
NOW() Obtenir la date du jour.
ROUND(...) Arrondit une valeur à une précision donnée. 
# Symbol to use
$symbol = "ZM.US"

# Lets get the officers data
$officers = MAP(F($symbol, "General.Officers"), $2)

# Lets get the age of each officer
$YearBorn = FILTER(MAP($officers, INDEX($3, 1)), $1)

# Lets get the average age
$YEAR = YEAR(NOW())
$ages = MAP($YearBorn, $YEAR - $1)
ROUND(AVG($ages))

Au 2023-05-25, le résultat est d'environ 50.

COUNT(ensemble)

La fonction COUNT(...) est utilisée pour obtenir le nombre de valeurs dans un ensemble. Le premier argument est l'ensemble de valeurs. Les exemples suivants illustrent l'utilisation de la fonction COUNT(...):

Exemples

# Get the number of values in a set
COUNT([1, 2, 3, 4, 5]) == 5

# Enumerate 50 ones and get the count, surprisingly it is 50!
COUNT(REPEAT(1, 50)) == 50

Cas d'utilisation : COUNT($secteurs)

Vous êtes en service et on vous demande de compter le nombre de secteurs dans lesquels ARKK.US a des actions ? C'est très simple :

Fonctions référencées Description
F(...) Extrait les données fondamentales d'un symbole boursier.
MAP(...) Établit une correspondance entre un ensemble de valeurs et un autre ensemble de valeurs.
FILTER(...) Filtre un ensemble de valeurs par une expression.
INDEX(...) Obtenir la valeur d'une clé dans un ensemble. 
# Symbol to use
$symbol = "ARKK.US"

# Lets get the sector data
$sectors = MAP(F($symbol, "ETF_Data.Sector_Weights"), [$1, INDEX($2, 'Equity_%')])

# Now lets exclude the sectors that have 0% equity
$sectors = FILTER($sectors, $2 > 0)

# Now lets count the number of sectors
COUNT($sectors)

Au 2023-05-25, le résultat est 6, le travail est fait !

INDEX(ensemble, index|clé)

La fonction INDEX(...) est utilisée pour obtenir une valeur à partir d'un ensemble. Le premier argument est l'ensemble de valeurs et le second est l'index ou la clé. Si vous souhaitez obtenir la première valeur de l'ensemble, vous pouvez utiliser INDEX($set, 0). Si vous souhaitez obtenir la dernière valeur de l'ensemble, vous pouvez utiliser INDEX($set, -1). Si vous souhaitez obtenir la valeur d'une clé dans un objet, vous pouvez utiliser INDEX($set, "key"). Les exemples suivants illustrent l'utilisation de la fonction INDEX(...):

Exemples

Index par position

# Get the first value in a set
$values = [1, 2, 3, 4, 5]

# Get the first value
INDEX($values, 0) == 1

# Get the last value
INDEX($values, -1) == 5

# Get the middle value
INDEX($values, FLOOR(COUNT($values) / 2)) == 3

Index par clé

# Declare an object
$obj = [[name, "John"], [age, 30]]

# Get the name
$name = INDEX($obj, "name")

# Get the age
$age = INDEX($obj, "age")

[$name, $age] == ["John", 30]

MAP(set, expression)

La fonction MAP(...) est utilisée pour transformer un ensemble de valeurs en un autre ensemble de valeurs. Le premier argument est l'ensemble de valeurs et le second est l'expression à évaluer pour chaque valeur de l'ensemble. L'expression peut être n'importe quelle expression qui renvoie une valeur. L'expression est évaluée avec les macros$1, $2, $3, ... fixées à la valeur de la valeur courante de l'ensemble. Les exemples suivants illustrent l'utilisation de la fonction MAP(...) :

Exemples

# Map a set of values to another set of values
MAP([1, 2, 3, 4, 5], $1 * 2) == [2, 4, 6, 8, 10]

# Map a set of values to another set of values
MAP([[name, 'Joe'], [age, 30]], $2) == ['Joe', 30]

Cas d'utilisation : MAP(F("AAPL.US", "General.Officers"), INDEX($2, 'Name'))

La fonction MAP(...) est utilisée dans de nombreux cas de figure lorsqu'il s'agit d'obtenir les données fondamentales d'une action. Par exemple, supposons que nous voulions obtenir les noms de tous les officiers de ZM.US. Nous pouvons le faire en utilisant la fonction MAP(...).

Fonctions référencées Description de la fonction
F(...) Extrait les données fondamentales d'un symbole boursier.
INDEX(...) Obtenir la valeur d'une clé dans un ensemble. 
# Lets get the names of each officer
MAP(F("AAPL.US", "General.Officers"), INDEX($2, 'Name'))

Au 2023-05-25, le résultat est le suivant :

    [Mr. Timothy D. Cook,
     Mr. Luca  Maestri,
     Mr. Jeffrey E. Williams,
     Ms. Katherine L. Adams,
     Ms. Deirdre  O'Brien,
     Mr. Chris  Kondo,
     Mr. James  Wilson,
     Ms. Mary  Demby,
     Ms. Nancy  Paxton,
     Mr. Greg  Joswiak]

FILTER(set, filter)

La fonction FILTER(...) est utilisée pour filtrer un ensemble de valeurs. Le premier argument est l'ensemble de valeurs et le second est l'expression de filtrage. L'expression de filtrage est généralement une assertion qui renvoie un résultat vrai ou faux. Si l'assertion est vraie, la valeur est conservée dans l'ensemble. Si l'assertion est fausse, la valeur est retirée de l'ensemble. L'expression de filtre peut être n'importe quelle expression renvoyant une valeur booléenne. Les exemples suivants illustrent l'utilisation de la fonction FILTER(...) :

Exemples

// Keep only the values that are greater than 10
FILTER([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], $1 > 5) == [6, 7, 8, 9, 10]

Cas d'utilisation : FILTER($price_change, $2 > 10)

Récupérons toutes les fins de journée où le changement de prix pour GLF.TO était supérieur à 10%. Nous pouvons le faire en utilisant la fonction FILTER(...). L'expression suivante renverra les fins de journée où la variation de prix était supérieure à 10 % :

Fonctions référencées Description de la fonction
S(...) Obtenir les données de fin de journée pour un symbole boursier.
MAP(...) Met en correspondance un ensemble de valeurs avec un autre ensemble de valeurs.
DATESTR(...) Formate une date en chaîne de caractères.
FILTER(...) Filtre un ensemble de valeurs par une expression. 
# Symbol to use
$symbol = "GFL.TO"

# Get the end of day data
$eod = S($symbol, open, ALL)

# Remap the data to get the price change
$price_change = MAP($eod, [DATESTR($1), (S($symbol, close, $1) - $2) / $2 * 100])

# Filter the data to get the price change greater than 10%
FILTER($price_change, $2 > 10)

Il s'avère que 2023-05-25 n'est arrivé qu'une seule fois:

[[2020-04-09, 10.2271]]

EVAL(expression)

La fonction EVAL(...) est utilisée pour évaluer une expression. L'expression peut être n'importe quelle expression qui renvoie une valeur. Cette fonction est principalement utile lorsqu'une autre fonction s'attend à ce qu'un argument de fonction soit appliqué en tant qu'expression, ce qui est vraiment méta et rarement utilisé.

Exemples d'application

Supposons que l'on vous donne une chaîne de caractères qui pourrait être une expression, et que vous souhaitiez l'évaluer. Vous pouvez le faire en utilisant la fonction EVAL(...). L'expression suivante renvoie le résultat de l'expression :

$outer_world_expression = "1 + 2"

EVAL($outer_world_expression) == 3

REPEAT(expression, count)

La fonction REPEAT(...) est utilisée pour répéter une expression un certain nombre de fois. L'expression peut être n'importe quelle expression qui renvoie une valeur. Les exemples suivants illustrent l'utilisation de la fonction REPEAT(...):

Exemples

# Repeat the expression 5 times
REPEAT(1 + 2, 5) == [3, 3, 3, 3, 3]

# Repeat the expression 5 times
REPEAT($i, 5) == [0, 1, 2, 3, 4]

REDUCE(ensemble, expression, initial)

La fonction REDUCE(...) est utilisée pour réduire un ensemble de valeurs à une seule valeur. Le premier argument est l'ensemble de valeurs, le deuxième argument est l'expression et le troisième argument est la valeur initiale. L'expression est généralement une opération qui renvoie une valeur. L'expression est évaluée pour chaque valeur de l'ensemble afin de produire la valeur réduite. Les exemples suivants illustrent l'utilisation de la fonction REDUCE(...):

Exemples

# Sum all the values in the set
REDUCE([1, 2, 3, 4, 5], $0 + $1, 0) == 15

# Automatically apply the second argument function with $0 and $1
REDUCE([1, 2, 3, 4, 5], ADD, 0) == 15

SORT(set[, order, index])

La fonction SORT(...) est utilisée pour trier un ensemble de valeurs. Le premier argument est l'ensemble de valeurs, le deuxième argument est l'ordre et le troisième argument est l'index. L'ordre peut être ASC ou DESC. L'index est l'index de la valeur de l'ensemble d'éléments à trier. Ceci est utile lorsque l'élément est un ensemble d'objets. Les exemples suivants illustrent l'utilisation de la fonction SORT(...):

Exemples

# Sort the set in ascending order
SORT([3, 2, 4, 1, 5], ASC) == [1, 2, 3, 4, 5]

# Sort the set in descending order
SORT([3, 2, 4, 1, 5], DESC) == [5, 4, 3, 2, 1]

# Sort the set in ascending order by the second value in the element set
SORT([[1, 3], [2, 2], [3, 4], [4, 1], [5, 5]], ASC, 1) == [[4, 1], [2, 2], [1, 3], [3, 4], [5, 5]]

ROUND(valeur, précision)

La fonction ROUND(...) est utilisée pour arrondir une valeur à une précision donnée. Le premier argument est la valeur et le second argument est la précision. Les exemples suivants illustrent l'utilisation de la fonction ROUND(...):

Exemples

# Round the value to 2 decimal places
ROUND(1.234, 2) == 1.23

# Round the value to 1 decimal place
ROUND(1.234, 1) == 1.2

FLOOR(valeur)

La fonction FLOOR(...) est utilisée pour arrondir une valeur vers le bas. Le premier argument est la valeur. Les exemples suivants illustrent l'utilisation de la fonction FLOOR(...) :

Exemples

# Round the value down
FLOOR(1.234) == 1

CEIL(valeur)

La fonction CEIL(...) est utilisée pour arrondir une valeur vers le haut. Le premier argument est la valeur. Les exemples suivants illustrent l'utilisation de la fonction CEIL(...):

Exemples

# Round the value up
CEIL(1.234) == 2

ABS(valeur)

La fonction ABS(...) est utilisée pour convertir une valeur en valeur absolue. Le premier argument est la valeur. Les exemples suivants illustrent l'utilisation de la fonction ABS(...) :

Exemples

# Convert the value to an absolute value
ABS(-1.234) == 1.234

RANDOM(lower, upper) ou RAND(...)

La fonction RANDOM(...) est utilisée pour générer un nombre aléatoire. Le premier argument est la borne inférieure inclusive et le deuxième argument est la borne supérieure exclusive. Les exemples suivants illustrent l'utilisation de la fonction RANDOM(...):

Exemples

# Generate a random number between 0 and 1
RAND() >= 0 && RANDOM(0, 1) < 1

# Generate a random number between 0 and 10
RAND(0, 10) >= 0 && RAND(0, 10) < 10

# Generate a random number between 1 and 10
RAND(1, 10) >= 1 && RAND(1, 10) < 10

IF(condition, expression_vraie, expression_faussée)

La fonction IF(...) est utilisée pour évaluer une condition et renvoyer une valeur en fonction de cette condition. Le premier argument est la condition, le deuxième argument est la valeur à renvoyer si la condition est vraie, et le troisième argument est la valeur à renvoyer si la condition est fausse.

Important : notez que seule l'expression true ou false est évaluée, et non les deux. Ceci est important lorsque l'expression est un appel de fonction qui a des effets secondaires.

Exemples d'utilisation

Les exemples suivants illustrent l'utilisation de la fonction IF(...):

# Return 1 if the condition is true, otherwise return 0
IF(1 == 1, 1, 0) == 1

# Return 1 if the condition is false, otherwise return 0
IF(1 == 2, 0, 1) == 1

WHILE(condition, expression)

La fonction WHILE(...) est utilisée pour évaluer une expression tant qu'une condition est vraie. Le premier argument est la condition et le second est l'expression. Les exemples suivants illustrent l'utilisation de la fonction WHILE(...):

Note : Attention aux boucles infinies !

Exemples

# Return the sum of the numbers from 1 to 10
i = 0
WHILE(i < 10, i = i + $0 + 1) == 15

Fonctions relatives aux chaînes de caractères

LPAD(valeur, pad, longueur)

La fonction LPAD(...) est utilisée pour remplir une valeur avec un tampon un certain nombre de fois. Le premier argument est la valeur, le deuxième argument est le pad et le troisième argument est la longueur maximale de la valeur paddée. Les exemples suivants illustrent l'utilisation de la fonction LPAD(...):

Exemples

# Build a date value
$date = DATE(2021, 1, 1)

# Get the month
$month = MONTH($date)

# Pad the month with a 0 so we always display months with 2 digits
LPAD($month, '0', 2) == "01"

RPAD(valeur, pad, longueur)

La fonction RPAD(...) est utilisée pour remplir une valeur avec un tampon un certain nombre de fois. Le premier argument est la valeur, le deuxième argument est le pad et le troisième argument est la longueur maximale de la valeur paddée. Les exemples suivants illustrent l'utilisation de la fonction RPAD(...):

Exemples

RPAD("4560 ", " ****", 19) == "4560 **** **** ****"

STARTS_WITH(valeur, préfixe)

La fonction STARTS_WITH(...) est utilisée pour vérifier si une valeur commence par un préfixe. Le premier argument est la valeur et le second le préfixe. Les exemples suivants illustrent l'utilisation de la fonction STARTS_WITH(...):

Exemples

# Check if the value starts with the prefix
STARTS_WITH("Hello World", "Hello") == true

ENDS_WITH(valeur, suffixe)

La fonction ENDS_WITH(...) est utilisée pour vérifier si une valeur se termine par un suffixe. Le premier argument est la valeur et le second le suffixe. Les exemples suivants illustrent l'utilisation de la fonction ENDS_WITH(...):

Exemples

# Check if the value ends with the suffix
ENDS_WITH("Hello World", "World") == true

FORMAT(format, valeur1, valeur2, ...)

Formateurs

Formateur Description Exemple
{0, hex} Formatage d'un entier en hexadécimal FORMAT("0x{0,hex}", 1234) == "0x1234"
{1,hex0x} Formatage d'un entier en hexadécimal avec le préfixe 0x et utilisation d'un remplissage nul sur 4 octets ou 8 octets pour les entiers de 64 bits FORMAT("{0,hex0x}", 0x1234) == "0x00001234"
{2,hex0x2} Formatage d'un entier en hexadécimal avec le préfixe 0x et utilisation d'un remplissage nul sur 2 octets FORMAT("0,hex0x2}", '\n') == "0x0a"
{3,lowercase} Formatage de la chaîne en minuscules FORMAT("{0,lowercase}", "HELLO") == "hello"
{4,majuscules} Formatage de la chaîne en majuscules FORMAT("{0,uppercase}", "heLLo") == "HELLO"
{5,devise} Formate le nombre en devise en utilisant le format 9 999 999.00 $. FORMAT("{0,currency}", 1234567.89) == "1 234 567.89 $"
{6,st} Formate la valeur entière 32 bits en tant que symbole dans la table de chaînes globale. Cela peut être utile pour le débogage. FORMAT("{0,st}", 666)
{7,translate} Formate la valeur de la chaîne en tant que traduction dans la table globale des chaînes. Cela peut être utile pour le débogage. FORMAT("{0,translate}", "Hello")
{8,abbreviate} Formate la valeur de la chaîne en tant que chaîne abrégée. Cela peut être utile pour le débogage. FORMAT("{0,abréger}", 100e6) == "100M"
{0, arrondi} Arrondir la valeur en virgule flottante à l'entier le plus proche FORMAT("{0,round}", 1234.5678) == "1235"
{1, since} Formate la valeur de la date en tant qu'heure depuis l'heure actuelle en utilisant le format il y a 1 jour, il y a 2 heures, il y a 3 minutes, il y a 4 secondes, etc. FORMAT("{0,since}", 1234567890) == "il y a 1 jour"
{2, date} Formate la valeur de la date en tant que date en utilisant le format AAAA-MM-JJ FORMAT("{0,date}", 1234567890) == "2009-02-13"

La fonction FORMAT(...) est utilisée pour formater une chaîne de caractères. Le premier argument est le format et le second est la valeur. Les exemples suivants illustrent l'utilisation de la fonction FORMAT(...):

Exemples

# Format a string value
FORMAT("Hello {0}", "World") == "Hello World"

$l = "Percent:"
$p = 44.519

FORMAT("{0} {1, 3} %", $l, $p) == "Percent: 44.5 %"

Fonctions de date

NOW()

La fonction NOW() est utilisée pour obtenir l'horodatage de la date courante. Les exemples suivants illustrent l'utilisation de la fonction NOW():

DATE(année, mois, jour)

La fonction DATE(...) est utilisée pour créer un horodatage. Le premier argument est l'année, le deuxième le mois et le troisième le jour. Les exemples suivants illustrent l'utilisation de la fonction DATE(...):

Exemples

# Create a date timestamp
DATE(2019, 1, 1) # => 1.54632e+09

DATE(chaîne)

La fonction DATE(...) est utilisée pour créer un horodatage. Le premier argument est la chaîne de caractères de la date. Les exemples suivants illustrent l'utilisation de la fonction DATE(...) :

Exemples

# Create a date timestamp
DATE("2019-01-01") == DATE(2019, 1, 1) # => true

DATESTR(date)

La fonction DATESTR(...) est utilisée pour créer une chaîne de dates. Le premier argument est l'horodatage de la date. Les exemples suivants illustrent l'utilisation de la fonction DATESTR(...) :

Exemples

# Create a date string
DATESTR(DATE(2019, 1, 1)) == "2019-01-01"

YEAR(date)

MONTH(date)

DAY(date)

Fonctions relatives aux actions

Les fonctions relatives aux actions sont utilisées pour obtenir des données relatives aux actions, telles que le prix d'une action à une certaine date, ou des données plus complexes, telles que la moyenne mobile d'une action sur une certaine période, etc.

Pour chacune des fonctions de stock, vous trouverez des exemples simples ainsi que la manière de les utiliser de manière plus complexe, par exemple pour une expression personnalisée de colonne de rapport.

Expressions de colonne

Lorsque vous écrivez une expression de colonne, vous pouvez vous appuyer sur quelques variables disponibles. Les variables suivantes sont disponibles dans une expression de colonne :

Les colonnes d'expression sont une fonction puissante qui vous permet de créer vos propres colonnes personnalisées. Vous pouvez utiliser n'importe quelle fonction intégrée ou créer vos propres fonctions personnalisées. Les exemples suivants illustrent l'utilisation des colonnes d'expression :

Expression Columns

S(symbole, champ[, date]), STOCK(...) OR EOD(...)

Alias : STOCK(...) OU EOD(...)

La fonction S(...) est utilisée pour obtenir une valeur à partir d'un symbole boursier. Le premier argument est le nom du symbole et le deuxième argument est le nom du champ. Le troisième argument est facultatif et correspond à la date à partir de laquelle le champ doit être obtenu. Vous pouvez également utiliser ALL comme date spéciale pour obtenir un tableau de toutes les valeurs du champ à toutes les dates.

Stock - Champs pris en charge

Champ Description
open prix d'ouverture de l'action
haut prix le plus élevé de l'action
bas cours le plus bas de l'action
haut prix le plus élevé de l'action
prix prix actuel de l'action
clôture cours de clôture de l'action
date date du prix actuel des données en temps réel
gmt décalage GMT du prix actuel à partir des données en temps réel
volume volume du prix actuel à partir des données en temps réel
hier prix de clôture de la veille
changement variation en $ entre l'ouverture et la fermeture
change_p variation en % de l'ouverture à la clôture (la valeur est déjà multipliée par 100)
change_p_high variation en % du plus haut au plus bas (la valeur est déjà multipliée par 100)
change_3d variation en % entre le niveau d'il y a 3 jours et le niveau de clôture
change_5d variation en % entre le jour précédent et le jour de clôture
change_1w variation en % depuis 1 semaine jusqu'à la clôture
change_2w variation en % depuis 2 semaines jusqu'à la clôture
change_4w variation en % depuis 4 semaines (~28 jours) jusqu'à la clôture
change_1m variation en % depuis 1 mois jusqu'à la clôture
change_2m variation en % depuis 2 mois jusqu'à la clôture
change_3m variation en % depuis 3 mois jusqu'à la clôture
change_6m variation en % depuis 6 mois jusqu'à la clôture
change_1y variation en % depuis 1 an jusqu'à la clôture
change_2y variation en % depuis 2 ans jusqu'à la clôture
change_3y variation en % depuis 3 ans jusqu'à la clôture
change_6y variation en % depuis 6 ans jusqu'à la clôture
change_10y variation en % depuis 10 ans jusqu'à la clôture
change_max variation en % entre le prix maximum et la clôture
wma moyenne mobile pondérée
ema moyenne mobile exponentielle
sma moyenne mobile simple
uband bande supérieure des bandes de Bollinger
mband bande moyenne des bandes de Bollinger
lband bande inférieure des bandes de Bollinger
sar SAR parabolique
pente pente de la régression linéaire
cci indice du canal des matières premières
dividendes rendement des dividendes en % (la valeur n' est pas multipliée par 100)
earning_trend_actual tendance réelle des revenus
earning_trend_estimate tendance de gain estimée
earning_trend_difference différence entre l'évolution réelle et l'évolution estimée de la rémunération
earning_trend_percent pourcentage de différence entre l'évolution réelle et l'évolution estimée des revenus
nom nom de l'action
description description de l'action
pays pays de l'action
secteur secteur de l'action
industrie secteur de l'action
type type de l'action
bêta bêta de l'action
devise devise de l'action
diluted_eps_ttm bénéfice dilué par action pour les 12 derniers mois
dma_200 moyenne mobile sur 200 jours
dma_50 moyenne mobile sur 50 jours
échange bourse de l'action
forward_pe ratio cours/bénéfice à terme
high_52 cours le plus élevé de l'action au cours des 52 dernières semaines
low_52 cours le plus bas de l'action au cours des 52 dernières semaines
market_cap capitalisation boursière
pe ratio cours/bénéfice
peg ratio prix/bénéfice sur la croissance
marge_de_bénéfice marge bénéficiaire
revenu_par_action_ttm revenu par action pour les 12 derniers mois
nombre_d'actions nombre d'actions du titre
short_percent pourcentage d'actions à découvert
short_ratio ratio court
symbole ticker/symbole de l'action
trailing_pe ratio cours/bénéfice
updated_at date à laquelle nous disposons des données les plus récentes pour l'action
url URL de l'action
ws_target Prix cible de Wall Street

Exemples d'utilisation

Les exemples suivants illustrent l'utilisation de la fonction S(...) :

# Get the current price of AAPL.US
S("AAPL.US", "price")

# Get the price change for the current day of U.US in $
S("U.US", "change")

# Get the price change for the current day of U.US in %
S("U.US", "change_p")

# Get the price change for the current day of U.US in % (value is already multiplied by 100)
S("U.US", "change_p_high")

# Get the moving average for the current day of U.US
S("U.US", "wma")

# Get the exponential moving average for the current day of U.US
S("GFL.TO", "ema")

Expressions de colonnes

Voici quelques exemples d'expressions de colonne que vous pouvez utiliser dans un rapport :

Split : S($TITLE, facteur_prix)

Prêt : ROUND((S($TITLE, close) / ((S($TITLE, dma_200)+S($TITLE, dma_50))/2))) * 100)

DMA : MAX(S($TITLE, dma_50), S($TITLE, dma_200))

S(symbole, champ, date)

Cette variante de la fonction S(...) est utilisée pour obtenir une valeur d'un symbole boursier pour une date spécifique. Le premier argument est le nom du symbole, le deuxième argument est le nom du champ et le troisième argument est la date. La date peut être une chaîne au format AAAA-MM-JJ ou un nombre de jours dans le passé. Le nom du champ peut être l'un des suivants :

Exemples

# You can use unix timestamps
S(TSL.TO, wma, 1661497600)

# Or dates in the format "YYYY-MM-DD"
S(PFE.US, close, "2018-01-01")

# The timestamp can always be converted to a date
S(TSL.TO, close, DATESTR(1671497600))

R(rapport, [titre,] champ)

Alias : REPORT(rapport, [titre,] champ)

La fonction R(...) est utilisée pour obtenir une valeur à partir d'un rapport. Le premier argument est le nom du rapport, le deuxième argument est le symbole du titre et le troisième argument est le nom du champ.

Champs des rapports pris en charge

Champ Description
vendu true si l'action a été vendue, false sinon
actif true si l'action est toujours active, false sinon
qty quantité possédée pour ce titre
buy coût d'achat moyen pour ce titre
jour variation journalière pour ce titre en fonction de la quantité possédée
prix_total_achat prix d'achat total pour ce titre
buy_total_quantity quantité totale achetée pour ce titre
sell_total_price prix de vente total pour ce titre
quantité_totale_de_vente quantité totale vendue pour ce titre
buy_total_price_rated prix d'achat total pour ce titre dans la devise du rapport
sell_total_price_rated prix de vente total pour ce titre dans la devise du rapport
prix_moyen prix moyen pour ce titre (ce prix est dans la devise du titre)
average_quantity quantité moyenne possédée pour ce titre
prix_demande moyen prix moyen demandé pour ce titre
taux de change moyen taux de change moyen pour ce titre
date_min date minimale pour ce titre
date_max date maximale pour ce titre
date_average date moyenne pour ce titre
days_held nombre de jours de détention pour ce titre pondéré par la quantité de chaque transaction
titre symbole du titre pour ce titre
ps ratio de tendance de prédiction pour ce titre
ask prix d'achat pour ce titre
taux de change du jour taux de change pour ce titre
gain gain pour ce titre dans la devise du rapport
gain_p gain pour ce titre en %
total_dividendes total des dividendes pour ce titre
valeur_totale valeur totale de ce titre dans la devise du rapport
total_investment investissement total pour ce titre dans la devise du rapport

Exemples

# Get the close price for TSLA.US in the report "300K"
R("300K", "TSLA.US", "close")

# Get how much dividends were paid for TNT-UN.TO in the report "300K"
R('300K', 'TNT-UN.TO', total_dividends)

# Returns true or false if the stock was completely sold
R('300K', 'GFL.TO', sold)

Liste de toutes les transactions pour un titre

Vous pouvez également utiliser le champ " transactions spéciales" pour obtenir une liste de toutes les transactions relatives à un titre. Cette fonction est utile si vous souhaitez effectuer des calculs personnalisés sur les transactions. Le champ transactions renvoie une liste de listes au format suivant :

R('300K', PFE.NEO, transactions)

Résultat :

    [[2022-05-30, 1.65389e+09, buy, 200, 25.8],
     [2022-06-09, 1.65475e+09, buy, 40, 25.6],
     [2022-06-20, 1.6557e+09, buy, 60, 22.73],
     [2023-01-05, 1.67289e+09, buy, 40, 23.7],
     [2023-01-10, 1.67333e+09, buy, 40, 22.96],
     [2023-01-11, 1.67341e+09, buy, 40, 22.53],
     [2023-01-12, 1.6735e+09, buy, 40, 22.48],
     [2023-03-07, 1.67817e+09, buy, 60, 19.26],
     [2023-03-08, 1.67825e+09, buy, 50, 19.06],
     [2023-03-09, 1.67834e+09, buy, 50, 18.96],
     [2023-04-12, 1.68128e+09, buy, 50, 19.77],
     [2023-04-18, 1.68179e+09, buy, 50, 19.36]]

Trouver le prix moyen des transactions qui ont un gain par rapport au prix d'aujourd'hui.

# Working title
$title='PFE.NEO'

# Get the current price
$current = S($title, close)

# Get all transactions for the title
$transactions = R('300K', $title, transactions)

# Filter the transactions to only keep the ones that have a gain
$transactions = FILTER($transactions, ($5 < $current) && ($3 == 'buy'))

# Get the average price of the transactions
$average = IF(COUNT($transactions) > 0, AVG(MAP($transactions, $5)), nan)

Expressions des colonnes

Récent : R($REPORT, $TITLE, date_max)

Ask II : R($REPORT, $TITLE, ask) * (1 + (1 - ((S($TITLE, close) / ((S($TITLE, dma_200)+S($TITLE, dma_50))/2)))))))

Dividendes : R($REPORT, $TITLE, buy_total_price) - R($REPORT, $TITLE, buy_total_adjusted_price)

GPrice : $current = S($TITLE, close),$transactions = FILTER(R($REPORT, $TITLE, transactions), ($5 < $current) && ($3 == 'buy')), IF(COUNT($transactions) > 0, AVG(MAP($transactions, $5)), nan)

F(symbole, champ)

Alias : FONDAMENTAUX(symbole, champ)

La fonction F(...) est utilisée pour obtenir une valeur fondamentale à partir d'un symbole. Le premier argument est le nom du symbole et le second est le nom du champ. Le nom du champ peut être à peu près n'importe quoi renvoyé par le point de terminaison /api/fundamentals.

FIELDS(titre, api)

Afin de découvrir les champs disponibles pour un symbole, vous pouvez utiliser la fonction FIELDS :

FIELDS("U.US", 'fundamentals')

Vous obtiendrez quelque chose comme ceci :

    [General.Code,
     General.Type,
     General.Name,
     General.Exchange,
     General.CurrencyCode,
     General.CurrencyName,
     General.CurrencySymbol,
     ...
     Technicals.Beta,
     ...
     SplitsDividends.PayoutRatio,
     ...]

Ensuite, lorsque vous avez une idée du champ que vous souhaitez utiliser, vous pouvez utiliser la fonction F(...) pour obtenir la valeur du champ :

Exemples

# Get the stock beta
F(TSLA.US, "Technicals.Beta") #=> 2.0705

# Get the stock industry
F(TSLA.US, "General.Industry") #=> Auto Manufacturers

Expressions de colonnes

Bêta : ROUND(F($TITLE, "Technicals.Beta") * 100)

RECHERCHE(texte)

La fonction SEARCH(...) est utilisée pour rechercher des symboles. L'argument est une expression textuelle qui sera évaluée pour obtenir les résultats de la recherche.

Exemples de recherche

SEARCH("boat country:canada")

En fonction des marchés que vous avez indexés, vous obtiendrez quelque chose comme ceci :

    [ADW-A.TO, 
     ADW-B.TO, 
     ADWPF.US, 
     BOAT.V, 
     BRMI.TO, 
     DOO.TO, 
     DOOO.US, 
     WCM-A.TO]

Ceci dit, vous pouvez vous rendre compte que, mélangé à d'autres fonctions, vous pouvez effectuer des recherches assez puissantes et les mélanger à d'autres fonctions.

# Get all the canadian companies that have the word "game" indexed
$game_companies = SEARCH("game country:canada")

# Map their current dma_200
$dma_200 = MAP($game_companies, [$1, S($1, dma_200)])

# This request can take a while to execute, so we cache the result
$dma_200 = FILTER($dma_200, $2 > 0.05)

Une fois la recherche terminée, vous obtiendrez quelque chose comme ceci :

    [[AMPDF.US, 0.0825],
     [APETF.US, 0.0598],
     [AXV.V, 0.2],
     ...
    ]

Fonctions graphiques

Les fonctions graphiques sont utiles lorsque vous souhaitez créer une expérience utilisateur personnalisée. Supposons que vous ayez une expression qui produit une liste de symboles, vous pouvez utiliser la fonction TABLE(...) pour créer une fenêtre de dialogue de tableau qui affichera les résultats.

TABLE(titre, ensemble, colonnes)

La fonction TABLE(...) est utilisée pour afficher une fenêtre de dialogue de tableau. Le premier argument est le titre du tableau, le deuxième argument est l'ensemble des valeurs à afficher dans le tableau et le troisième argument est les colonnes à afficher dans le tableau.

Exemples

Présenter dans un tableau les composants d'un *.INDX donné

$index = "IXIC.INDX" # Work with the following index

# Get index name
$name = F($index, "General.Name")

# Get index components
$components = F($index, "Components")

# Map components to [code, name, sector, industry]
$components = MAP($components,
    [INDEX($2, 0, 1) + '.' + INDEX($2, 1, 1), 
     INDEX($2, 2, 1),
     INDEX($2, 3, 1),
     INDEX($2, 4, 1)])

# Load index components table
TABLE($name, $components,
    ['Symbol', $1, 'symbol'],
    ['Name', $2],
    ['Sector', $3],
    ['Industry', $4])

Si vous collez cette expression dans la console, vous obtiendrez quelque chose comme ceci :

Table

Je vous vois venir, vous voulez trier le tableau par secteur, pas de problème, il suffit de cliquer sur l'en-tête de la colonne.

Il y a trop de colonnes, supprimons les colonnes secteur et industrie.

Table

Vous pouvez également exporter le tableau vers un fichier CSV.

PLOT(titre, x_set, y_set, options)

La fonction PLOT(...) est utilisée pour afficher une fenêtre de dialogue de tracé. Le premier argument est le titre du graphique, le deuxième argument est l'ensemble des valeurs à afficher sur l'axe des x, le troisième argument est l'ensemble des valeurs à afficher sur l'axe des y et le quatrième argument est les options pour le graphique.

Il est important de noter que les ensembles x et y doivent avoir la même taille.

Options

Voici une liste des options disponibles :

Exemples

Supposons que nous voulions représenter les estimations du bénéfice par action des derniers trimestres pour Bombardier Inc. (BBD-B.TO).

$stock = "BBD-B.TO" # Work with the following stock

# Get stock name
$name = F($stock, "General.Name")

# Get stock EPS estimates
$earnings = MAP(F($stock, "Earnings.History"), [INDEX($2, 'reportDate'), INDEX($2, 'epsEstimate')])

# Remove the null values
$earnings = FILTER($earnings, $2 != nil)

# Plot the earnings estimates, we transform the date to a timestamp
PLOT($name + ' - Earning estimates', MAP($earnings, DATE($1)), MAP($earnings, $2), "xtime")

Si vous collez cette expression dans la console, vous obtiendrez quelque chose comme ceci :

Plot

Vous devriez également voir apparaître une fenêtre de dialogue de tracé.

Plot

Si vous aimez ce que vous voyez, vous pouvez appuyer sur F11 pour capturer le tracé et l'enregistrer au format PNG.

Console
La plupart des exemples qui suivent peuvent être collés directement dans la console de l'application. Pour ouvrir la console, appuyez sur F10 ou cliquez sur l'élément de menu Fenêtre/Console. Une fois l'expression collée, appuyez sur Eval pour l'exécuter.

Lorsque vous voyez des sections de code avec
#---
$VAR=valeur
#---
cela signifie généralement que vous pouvez adapter ces variables à vos besoins.		 Console

Exemples

Accueil » Manuel de l'utilisateur » Expressions