cumprod produit cumulatif des éléments d'un tableau.

## Séquence d'appel

              y = cumprod(x)
              y = cumprod(x, orientation)
              y = cumprod(x, outtype)
              y = cumprod(x, orientation, outtype)

## Paramètres

x

  un tableau de réels, de complexes, de booléens, de polynômes ou de fractions rationnelles.

orientation

  Cet argument peut être

  - ou une chaîne de caractères pouvant avoir comme valeurs: `"*"`, `"r"`, `"c"` ou `"m"`

  - ou bien un nombre à valeur positive entière

outtype

  une chaîne de caractères pouvant prendre les valeurs `"native"` ou `"double"`.

y

  un scalaire ou un tableau

## Description

Pour un tableau `x`, `y=cumprod(x)` renvoie dans `y` le produit cumulatif de tous les éléments de `x`.

`y=cumprod(x,orientation)` retourne dans `y` le produit cumulatif des éléments de `x` le long de la dimension donnée par le paramètre `orientation`:

- Si `orientation` est égal à 1 ou "r" alors:

  y(\mathbf{l},j) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j)

  ou

  y(\mathbf{l},j,k,\ldots) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j,k,\ldots)

- Si `orientation` est égal à 2 ou "c" alors:

  y(i,\mathbf{l}) = \prod_{\mathbf{j}=1}^l x(i,{\mathbf{j})

  ou

  y(i,\mathbf{l},k,\ldots) = \prod_{\mathbf{j}=1}^l x(i,\mathbf{j},k,\ldots)

- Si `orientation` est égal à n alors:

  y(i_1,\ldots,i_{n-1},\mathbf{l},i_{n+1},\ldots) = \prod_{\mathbf{i_n}=1}^l x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)

- `y=cumprod(x,"*")` est équivalent à `y=cumprod(x)`

- `y=cumprod(x,"m")` est équivalent à `y=cumprod(x,orientation)` où `orientation` est l'index de la première dimension de `x` qui est plus grande que 1. Cette option est utilisé pour la compatibilité avec Matlab.

L'argument `outtype` gère la façon dont le produit est réalisé :

- Pour les matrices de doubles, de polynômes, de fractions rationnelles, l'évaluation est toujours effetuée sur des nombres à virgule flottante. Les options `"double"` ou `"native"` sont équivalentes (par défaut, `outtype = "double"`).

- Pour les tableaux d'entiers,

  si `outtype="native"`, le calcul est effectué sur des nombres entiers (modulo 2^b, où b est le nombre de bits utilisés).

  si `outtype="double"`, le calcul est effectué sur des nombres à virgule flottante.

  La valeur par défaut est `outtype="native"`

- Pour les tableaux de booléens,

  si `outtype="native"`, le calcul est effectué sur des booléens (* est remplacée par &),

  si `outtype="double"`, le calcul est effectué sur des nombres à virgule flottante (%t est remplacé par 1 et %f par 0).

  La valeur par défaut est `outtype="double"`

## Remarque

Cette fonction s'applique avec les mêmes règles aux matrices creuses et aux hypermatrices.

## Exemples

    A=[1,2;3,4];
    cumprod(A)
    cumprod(A,1)

    I=uint8([2 95 103;254 9 0])
    cumprod(I) // Evaluation "native"
    cumprod(I,"double")
    cumprod(I,2,"double")

    s=poly(0,"s");
    P=[s,%i+s;s^2,1];
    cumprod(P),
    cumprod(P,2)

    B=[%t %t %f %f];
    cumprod(B) // Evaluation en flottant
    cumprod(B,"native") // Equivalent à and(B)

## Voir aussi

- cumsum
- prod