\documentclass[11pt]{article}

\input{packages.tex}
\input{tikz.tex}
\input{thmstyle.tex}
\input{macros.tex}

\title{Lattices of compatibly embedded finite fields}
\author{}

\begin{document}
\maketitle
\begin{center}

    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[arrow] (E) -- (F);
      \draw[arrow] (E) -- (G);
      \draw[arrow] (F) -- (G);

      \node (f12) at (1.25, 0.25) {$\embed{E}{F}$};
      \node (f13) at (-0.35, 1) {$\embed{E}{G}$};
      \node (f23) at (1.6, 1.65) {$\embed{F}{G}$};
    \end{tikzpicture}

\end{center}

\section{Introduction}

Given two finite fields $E$ and $F$ with cardinalities $|E|=p^{m}$ and
$|F|=p^{n}$, we know that $E$ can be embedded in $F$ if and only if $m\,|\,n$.
In other words, $E$ is in that case isomorphic to a subfield $E'\subset F$ of $F$ with
cardinality $|E'|=p^{m}$. There are
$m=[E:\mathbb{F}_p]=|\Gal(E/\mathbb{F}_p)|$ disctinct embeddings from $E$ to
$F$ (the degree of $E$ over $\mathbb{F}_p$ will also be denoted by
$\partial(E)$). Indeed, the Galois group of the extension $E$ over $\mathbb{F}_p$ acts
on the embeddings. Given two different embeddings $\embed{E}{F}$ and
$\embed{E}{F}'$ and an element $x\in E$, the images $\embed{E}{F}(x)$ and
$\embed{E}{F}'(x)$ must be conjugates. As a result, there is no cannonical
embedding from $E$ to $F$. Furthermore, the proof of the fact that $E$ can be
embedded in $F$ if and only if $\dE\,|\,\dF$ is not constructive, so computing the
embedding is itself a challenging problem, and there exists a variety of
solutions.

In this document, we do not recall the embeddings algorithms, we often
consider them as black boxes that we use to construct embeddings between
finite fields, and we study the compatibility between these embeddings. Given
three finite fields $E$, $F$, and $G$, such that $\dE\,|\,\dF$ and $\dF\,|\,\dG$, and three embeddings
$\embed{E}{F}$, $\embed{F}{G}$, and $\embed{E}{G}$, we say that the
embeddings are \emph{compatible} if
\[
  \embed{E}{G}=\embed{F}{G}\circ\embed{E}{F}.
\]
In other words, we want the diagram of Figure~\ref{fig:compatibility} to
commute. We also note $E\emb F$ if $E$ is explicitly embedded in $F$, \ie if
we have computed an embedding $\embed{E}{F}$.
\begin{figure}
  \centering
    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[arrow] (E) -- (F);
      \draw[arrow] (E) -- (G);
      \draw[arrow] (F) -- (G);

      \node (f12) at (1.25, 0.25) {$\embed{E}{F}$};
      \node (f13) at (-0.35, 1) {$\embed{E}{G}$};
      \node (f23) at (1.6, 1.65) {$\embed{F}{G}$};
    \end{tikzpicture}

  \caption{Embeddings between finite fields.}
  \label{fig:compatibility}
\end{figure}
The background of this work is the development of a computer algebra
software, where we want the user to be able to define arbitrary finite
fields and to work with them without having to care about compatibility
between the different embeddings he or she have to use. These goals are
achieved in the computer algebra softwares MAGMA~\cite{Magma} and
Sagemath~\cite{Sagemath}. We introduce the
framework of Bosma, Cannon and Steel~\cite{BCS97} in
Section~\ref{sec:bcs-framework}. Next, we discuss the current implementation in
Nemo of
this framework in Section~\ref{sec:implem}.

\section{Bosma, Cannon, and Steel framework}
\label{sec:bcs-framework}
\begin{figure}
  \centering
    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[arrow] (E) -- (F);
      \draw[arrow] (E) -- (G);
      \draw[dashed-arrow] (F) -- (G);

      \node (f12) at (1.25, 0.25) {$\embed{E}{F}$};
      \node (f13) at (-0.35, 1) {$\embed{E}{G}$};
    \end{tikzpicture}

  \caption{An uncomplete diagram.}
  \label{fig:uncomplete}
\end{figure}

Let $E$, $F$, and $G$ be finite fields with
$\partial(E)\,|\,\partial(F)$ and
$\partial(F)\,|\,\partial(G)$. We also assume that $E\emb F$ and $E\emb G$,
hence we are in the situation described by Figure~\ref{fig:uncomplete}
where we miss one embedding. In order to complete the diagram of this
figure, Bosma,
Cannon and Steel suggest to take an arbitrary embedding $\embed{F}{G}'$ and to
``correct'' it by composing $\embed{F}{G}'$ with an element of
$\sigma\in\Gal(G/\mathbb{F}_p)$ such that
\[
  \embed{E}{G}=\sigma\circ\embed{F}{G}'\circ\embed{E}{F}.
\]
We can then set $\embed{F}{G}=\sigma\circ\embed{F}{G}'$ and the
obtained embedding is compatible by construction. We also see that once we have
one compatible embedding, we can derive other compatible embeddings from it by
precomposing by an element $\xi$ of $\Gal(F/E)$. Indeed, such an element
$\xi$ fixes the elements in $E$, hence the compatibility conditions are
still verified after precomposition. One may wander what happens
if there are several subfields $E_1, \dots, E_r$, or if the configuration is not
the one presented in Figure~\ref{fig:uncomplete}.

There are three configurations with triangles, that are the one in
Figure~\ref{fig:triangles}. We already discussed the configuration on the
left, which is the one in Figure~\ref{fig:uncomplete}. The configuration in the
middle is easier to handle because we can set
\[
  \embed{E}{G}=\embed{F}{G}\circ\embed{E}{F}
\]
since we have $E\emb F\emb G$. Finally, we will see later that the
configuration on the right cannot happen in the framework we use because on the
conditions we impose on the finite fields and on the embeddings betweem them.
  \begin{figure}
    \centering
    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[arrow] (E) -- (F);
      \draw[arrow] (E) -- (G);
      \draw[dashed-arrow] (F) -- (G);
    \end{tikzpicture}
    \phantom{and}
    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[arrow] (E) -- (F);
      \draw[dashed-arrow] (E) -- (G);
      \draw[arrow] (F) -- (G);

    \end{tikzpicture}
    \phantom{and}
    \begin{tikzpicture}
      \node (E) at (0, 0) {$E$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};

      \draw[dashed-arrow] (E) -- (F);
      \draw[arrow] (E) -- (G);
      \draw[arrow] (F) -- (G);

    \end{tikzpicture}
    \caption{The different configurations with triangles.}
    \label{fig:triangles}
  \end{figure}

If we have a pair $\mathfrak L=(L, \Phi)$, where
$L$ is a set of finite fields and $\Phi$ is a set of embeddings between
elements of $L$, we say that $\mathfrak L$ is a \emph{lattice of compatibly
embedded finite fields} if
\begin{enumerate}
  \item[CE1] (unicity) for each pair $(E, F)$ of elements in $L$, there exists
    at most one corresponding embedding $\embed{E}{F}\in\Phi$.
  \item[CE2] (reflexivity) For each $E\in L$, the identity map
    $\Id_E=\embed{E}{E}$ is in $\Phi$.
  \item[CE3] (prime subfield) There is exactly one $P\in L$ such that $\partial
    (P) = 1$, and for all $F\in L$, there exists $\embed{P}{F}\in\Phi$
  \item[CE4] (invertibility) If $E\emb F$ and $\dE=\dF$, then $F\emb E$ and
    $\embed{F}{E}=\embed{E}{F}^{-1}$.
  \item[CE5] (transitivity) For any triple $(E, F, G)$ of elements in $L$, if $E\emb
    F\emb G$ then $E\emb G$ and
    $\embed{E}{G}=\embed{F}{G}\circ\embed{E}{F}$.
  \item[CE6](intersections) For each $E, F, G\in L$ such that $F\emb G$ and
    $E\emb G$, there exists $S\in L$ such that $\partial(S)=\gcd(\dE, \dF)$
    and $S\emb E$, $S\emb F$.
\end{enumerate}
These conditions are, for most of them, very natural. The condition CE3 is
technical and does not imply any work in our implementation because
finite fields elements in Nemo/Flint~\cite{Nemo, Flint} are represented by
polynomials over $\mathbb{F}_p$, so the embedding of $\mathbb{F}_p$ into an
extension is trivial. Finally, condition
CE6 ensures that the implicit isomorphisms between subfields are made
explicit.

Under those conditions, we can prove~\cite{BCS97} that we are able to add a finite field in
$L$ or an embedding that is not yet in $\Phi$ without altering the compatibility
of the lattice $\mathfrak L$.

\section{Implementation in Nemo}
\label{sec:implem}
In practice, we do not compute our embeddings by correcting random embeddings as
suggested in Section~\ref{sec:bcs-framework}. Instead, we use the naive
algorithm to compute a compatible embedding that does not need any correction.
Assume we are in the situation of Figure~\ref{fig:uncomplete}, \ie we have $E$,
$F$, $G$ finite fields and $E\emb F$, $E\emb G$, $\dF\,|\,\dG$. Let $\alpha_F$
be a generator of $F$ over $\mathbb{F}_p$, then $\alpha_F$ is also a generator
of $F$ over $E$. Let $\pi_{E}(\alpha_F)$ be the minimal polynomial of $\alpha_F$
over $E$, and let $\rho$ be a root of $\embed{E}{G}(\pi_E(\alpha_F))$, the
minimal polynomial of $\alpha_F$ viewed in $G$. We set $\embed{F}{G}$ to the
embedding mapping $\alpha_F$ to $\rho$. More precisely, we set
\[
  \embed{F}{G}(\sum_{i=0}^{[F:E]-1}e_i\alpha_F^i) =
  \sum_{i=0}^{[F:E]-1}\embed{E}{G}(e_i)\rho^i,
\]
hence we see that
\[
  \embed{E}{G} = \embed{F}{G}\circ\embed{E}{F}
\]
and the new embedding is compatible with the already existing ones. We take
the cannonical generator of $F$ over $\mathbb{F}_p$ to be $\alpha_F$, we compute
$\pi_E(\alpha_F)$ using linear algebra and we compute $\embed{F}{G}$ using
linear algebra too. Assume now that we have several finite fields $E_1, \cdots, E_r$ such
that for all $j$, $E_j\emb F$, $E_j\emb G$ and $\dF\,|\,\dG$. This is the
situation of Figure~\ref{fig:uncomplete-sev}.
\begin{figure}
  \centering
    \begin{tikzpicture}
      \node (E1) at (-2, 0) {$E_1$};
      \node (E2) at (-1, 0) {$E_2$};
      \node (Er) at (0.75, 0) {$E_r$};
      \node (F) at (1.5, 1) {$F$};
      \node (G) at (0.5, 2) {$G$};
      \node (p) at (0, 0) {$\dots$};

      \draw[arrow] (E1) -- (F);
      \draw[arrow] (E1) -- (G);
      \draw[arrow] (E2) -- (F);
      \draw[arrow] (E2) -- (G);
      \draw[arrow] (Er) -- (F);
      \draw[arrow] (Er) -- (G);
      \draw[dashed-arrow] (F) -- (G);
  \end{tikzpicture}
  \caption{An uncomplete diagram with several subfields.}
  \label{fig:uncomplete-sev}
\end{figure}
In that case, we consider the polynomial
\[
  P = \gcd_i(\embed{E_i}{G}(\pi_{E_i}(\alpha_F))),
\]
and we let $\rho$ be a root of $P$. We see that $\rho$ is a root of each
polynomial $\embed{E_i}{G}(\pi_{E_i}(\alpha_F))$, so the embedding mapping
$\alpha_F$ to $\rho$ is compatible with all the previously existing embeddings.

\section{Conclusion}

In practice, because of condition CE6 concerning intersections, we might have to
compute additionnal embeddings before computing the wanted embedding. In
conclusion, in order to embed a finite field $F$ in $G$, we have to:

\begin{enumerate}
  \item for each subfield $S$ of $G$, check if the finite field $S\cap F$ is
    embedded in $S$ and $F$, and if not, embed it. In practice, if there is not
    any finite field of degree $d=\gcd(\partial(S), \dF)$, we compute an
    arbitrary finite field $I$ of degree $d$ using Flint
    and we embed $I$ in $S$ and $F$.
  \item Embed $F$ in $G$ using Section~\ref{sec:implem} procedure.
  \item Compute the ``transitive closure'' of the lattice, \ie compute the
    embeddings such that condition CE5 holds. In practice we compute all the
    embeddings and keep them in memory.
\end{enumerate}
The first step implies a recursive call to our embedding algorithm, so the
complexity of the operation might explode at that step.

There are several things that could be enhanced in our current framework. First,
we could use graph algorithms in order to compute the transitive closure only
when asked by the user. We could also compute minimal polynomials using
Berlekamp Massey algorithm instead of linear algebra.

\bibliographystyle{plain}
\bibliography{erou}
\end{document}


%
% API Documentation for Peach - Computational Intelligence for Python
% Module peach.fuzzy.mf
%
% Generated by epydoc 3.0beta1
% [Mon Dec 21 08:51:36 2009]
%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                          Module Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}|(}
\section{Module peach.fuzzy.mf}

    \label{peach:fuzzy:mf}

Membership functions

Membership functions are actually subclasses of a main class called Membership,
see below. Instantiate a class to generate a function, optional arguments can be
specified to configure the function as needed. For example, to create a triangle
function starting at 0, with peak in 3, and ending in 4, use:
\begin{quote}{\ttfamily \raggedright \noindent
mu~=~Triangle(0,~3,~4)
}\end{quote}

Please notice that the return value is a \emph{function}. To use it, apply it as a
normal function. For example, the function above, applied to the value 1.5
should return 0.5:
\begin{quote}{\ttfamily \raggedright \noindent
>{}>{}>~print~mu(1.5)~\\
0.5
}\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                               Functions                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsection{Functions}

    \label{peach:fuzzy:mf:Saw}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Saw \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{Saw}(\textit{interval}, \textit{n})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Splits an \texttt{interval} into \texttt{n} triangle functions.

Given an interval in any domain, this function will create \texttt{n} triangle
functions of the same size equally spaced in the interval. It is very
useful to create membership functions for controllers. The command below
will create 3 triangle functions equally spaced in the interval (0, 4):
\begin{quote}{\ttfamily \raggedright \noindent
mf1,~mf2,~mf3~=~Saw((0,~4),~3)
}\end{quote}

This is the same as the following commands:
\begin{quote}{\ttfamily \raggedright \noindent
mf1~=~Triangle(0,~1,~2)~\\
mf2~=~Triangle(1,~2,~3)~\\
mf3~=~Triangle(2,~3,~4)
}\end{quote}
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xxxxxxxx}

          \item[interval]

A tuple containing the start and the end of the interval, in the format
\texttt{(start, end)};
          \item[n]

The number of functions in which the interval must be split.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A list of triangle membership functions, in order.
      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{peach:fuzzy:mf:FlatSaw}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.FlatSaw \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{FlatSaw}(\textit{interval}, \textit{n})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Splits an \texttt{interval} into a decreasing ramp, \texttt{n-2} triangle functions
and an increasing ramp.

Given an interval in any domain, this function will create a decreasing ramp
in the start of the interval, \texttt{n-2} triangle functions of the same size
equally spaced in the interval, and a increasing ramp in the end of the
interval. It is very useful to create membership functions for controllers.
The command below will create a decreasing ramp, a triangle function and an
increasing ramp equally spaced in the interval (0, 2):
\begin{quote}{\ttfamily \raggedright \noindent
mf1,~mf2,~mf3~=~FlatSaw((0,~2),~3)
}\end{quote}

This is the same as the following commands:
\begin{quote}{\ttfamily \raggedright \noindent
mf1~=~DecreasingRamp(0,~1)~\\
mf2~=~Triangle(0,~1,~2)~\\
mf3~=~Increasingramp(1,~2)
}\end{quote}
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xxxxxxxx}

          \item[interval]

A tuple containing the start and the end of the interval, in the format
\texttt{(start, end)};
          \item[n]

The number of functions in which the interval must be split.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A list of corresponding functions, in order.
      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                               Variables                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsection{Variables}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-d\-o\-c\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt \texttt{...}}&\\
\cline{1-2}
\end{longtable}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Membership \textit{(class)}|(}
\subsection{Class Membership}

    \label{peach:fuzzy:mf:Membership}
\begin{tabular}{cccccc}
% Line for object, linespec=[False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
  \\
&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.Membership}}
\end{tabular}

\textbf{Known Subclasses:}
peach.fuzzy.mf.Bell,
    peach.fuzzy.mf.DecreasingRamp,
    peach.fuzzy.mf.DecreasingSigmoid,
    peach.fuzzy.mf.Gaussian,
    peach.fuzzy.mf.IncreasingRamp,
    peach.fuzzy.mf.IncreasingSigmoid,
    peach.fuzzy.mf.RaisedCosine,
    peach.fuzzy.mf.Trapezoid,
    peach.fuzzy.mf.Triangle

Base class of all membership functions.

This class is used as base of the implemented membership functions, and can
also be used to transform a regular function in a membership function that
can be used with the fuzzy logic package.

To create a membership function from a regular function \texttt{f}, use:
\begin{quote}{\ttfamily \raggedright \noindent
mf~=~Membership(f)
}\end{quote}

A function this converted can be used with vectors and matrices and always
return a FuzzySet object. Notice that the value range is not verified so
that it fits in the range {[} 0, 1 {]}. It is responsibility of the programmer
to warrant that.

To subclass Membership, just use it as a base class. It is suggested that
the \texttt{{\_}{\_}init{\_}{\_}} method of the derived class allows configuration, and the
\texttt{{\_}{\_}call{\_}{\_}} method is used to apply the function over its arguments.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{f})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Builds a membership function from a regular function
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{x}

          \item[f]

Function to be transformed into a membership function. It must be
given, and it must be a \texttt{FunctionType} object, otherwise, a
\texttt{ValueError} is raised.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: object.\_\_init\_\_

    \end{boxedminipage}

    \label{peach:fuzzy:mf:Membership:__call__}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Membership \textit{(class)}!peach.fuzzy.mf.Membership.\_\_call\_\_ \textit{(method)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Maps the function on a vector
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{x}

          \item[x]

A value, vector or matrix over which the function is evaluated.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Membership \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.IncreasingRamp \textit{(class)}|(}
\subsection{Class IncreasingRamp}

    \label{peach:fuzzy:mf:IncreasingRamp}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.IncreasingRamp}}
\end{tabular}

Increasing ramp.

Given two points, \texttt{x0} and \texttt{x1}, with \texttt{x0 < x1}, creates a function
which returns:
\begin{quote}

0, if \texttt{x <= x0};

\texttt{(x - x0) / (x1 - x0)}, if \texttt{x0 < x <= x1};

1, if \texttt{x > x1}.
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}, \textit{x1})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Start of the ramp;
          \item[x1]

End of the ramp.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.IncreasingRamp \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.DecreasingRamp \textit{(class)}|(}
\subsection{Class DecreasingRamp}

    \label{peach:fuzzy:mf:DecreasingRamp}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.DecreasingRamp}}
\end{tabular}

Decreasing ramp.

Given two points, \texttt{x0} and \texttt{x1}, with \texttt{x0 < x1}, creates a function
which returns:
\begin{quote}

1, if \texttt{x <= x0};

\texttt{(x1 - x) / (x1 - x0)}, if \texttt{x0 < x <= x1};

0, if \texttt{x > x1}.
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}, \textit{x1})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Start of the ramp;
          \item[x1]

End of the ramp.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.DecreasingRamp \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Triangle \textit{(class)}|(}
\subsection{Class Triangle}

    \label{peach:fuzzy:mf:Triangle}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.Triangle}}
\end{tabular}

Triangle function.

Given three points, \texttt{x0}, \texttt{x1} and \texttt{x2}, with \texttt{x0 < x1 < x2},
creates a function which returns:
\begin{quote}

0, if \texttt{x <= x0} or \texttt{x > x2};

\texttt{(x - x0) / (x1 - x0)}, if \texttt{x0 < x <= x1};

\texttt{(x2 - x) / (x2 - x1)}, if \texttt{x1 < x <= x2}.
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}, \textit{x1}, \textit{x2})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Start of the triangle;
          \item[x1]

Peak of the triangle;
          \item[x2]

End of triangle.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Triangle \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Trapezoid \textit{(class)}|(}
\subsection{Class Trapezoid}

    \label{peach:fuzzy:mf:Trapezoid}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.Trapezoid}}
\end{tabular}

Trapezoid function.

Given four points, \texttt{x0}, \texttt{x1}, \texttt{x2} and \texttt{x3}, with
\texttt{x0 < x1 < x2 < x3}, creates a function which returns:
\begin{quote}

0, if \texttt{x <= x0} or \texttt{x > x3};

\texttt{(x - x0)/(x1 - x0)}, if \texttt{x0 <= x < x1};

1, if \texttt{x1 <= x < x2};

\texttt{(x3 - x)/(x3 - x2)}, if \texttt{x2 <= x < x3}.
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}, \textit{x1}, \textit{x2}, \textit{x3})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Start of the trapezoid;
          \item[x1]

First peak of the trapezoid;
          \item[x2]

Last peak of the trapezoid;
          \item[x3]

End of trapezoid.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Trapezoid \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Gaussian \textit{(class)}|(}
\subsection{Class Gaussian}

    \label{peach:fuzzy:mf:Gaussian}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.Gaussian}}
\end{tabular}

Gaussian function.

Given the center and the width, creates a function which returns a gaussian
fit to these parameters, that is:
\begin{quote}

\texttt{exp(-a*(x - x0)**2)}
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}=\texttt{0.0}, \textit{a}=\texttt{1.0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Center of the gaussian. Default value \texttt{0.0};
          \item[a]

Width of the gaussian. Default value \texttt{1.0}.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Gaussian \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.IncreasingSigmoid \textit{(class)}|(}
\subsection{Class IncreasingSigmoid}

    \label{peach:fuzzy:mf:IncreasingSigmoid}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.IncreasingSigmoid}}
\end{tabular}

Increasing Sigmoid function.

Given the center and the slope, creates an increasing sigmoidal function.
It goes to \texttt{0} as \texttt{x} approaches to -infinity, and goes to \texttt{1} as
\texttt{x} approaches infinity, that is:
\begin{quote}

\texttt{1 / (1 + exp(-a*(x - x0))}
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}=\texttt{0.0}, \textit{a}=\texttt{1.0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Center of the sigmoid. Default value \texttt{0.0}. The function evaluates
to \texttt{0.5} if \texttt{x = x0};
          \item[a]

Slope of the sigmoid. Default value \texttt{1.0}.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.IncreasingSigmoid \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.DecreasingSigmoid \textit{(class)}|(}
\subsection{Class DecreasingSigmoid}

    \label{peach:fuzzy:mf:DecreasingSigmoid}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.DecreasingSigmoid}}
\end{tabular}

Decreasing Sigmoid function.

Given the center and the slope, creates an decreasing sigmoidal function.
It goes to \texttt{1} as \texttt{x} approaches to -infinity, and goes to \texttt{0} as
\texttt{x} approaches infinity, that is:
\begin{quote}

\texttt{1 / (1 + exp(a*(x - x0))}
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}=\texttt{0.0}, \textit{a}=\texttt{1.0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Center of the sigmoid. Default value \texttt{0.0}. The function evaluates
to \texttt{0.5} if \texttt{x = x0};
          \item[a]

Slope of the sigmoid. Default value \texttt{1.0}.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.DecreasingSigmoid \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.RaisedCosine \textit{(class)}|(}
\subsection{Class RaisedCosine}

    \label{peach:fuzzy:mf:RaisedCosine}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.RaisedCosine}}
\end{tabular}

Raised Cosine function.

Given the center and the frequency, creates a function that is a period of
a raised cosine, that is:
\begin{quote}

0, if \texttt{x <= xm - pi/w} or \texttt{x > xm + pi/w};

\texttt{0.5 + 0.5 * cos(w*(x - xm))}, if \texttt{xm - pi/w <= x < xm + pi/w};
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{xm}=\texttt{0.0}, \textit{w}=\texttt{1.0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[xm]

Center of the cosine. Default value \texttt{0.0}. The function evaluates
to \texttt{1} if \texttt{x = xm};
          \item[w]

Frequency of the cosine. Default value \texttt{1.0}.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.RaisedCosine \textit{(class)}|)}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Bell \textit{(class)}|(}
\subsection{Class Bell}

    \label{peach:fuzzy:mf:Bell}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for peach.fuzzy.mf.Membership, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{peach.fuzzy.mf.Membership}\multirow{2}{\BCL}{peach.fuzzy.mf.Membership}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.mf.Bell}}
\end{tabular}

Generalized Bell function.

A generalized bell is a symmetric function with its peak in its center and
fast decreasing to \texttt{0} outside a given interval, that is:
\begin{quote}

\texttt{1 / (1 + ((x - x0)/a)**(2*b))}
\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{x0}=\texttt{0.0}, \textit{a}=\texttt{1.0}, \textit{b}=\texttt{1.0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the function.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{xx}

          \item[x0]

Center of the bell. Default value \texttt{0.0}. The function evaluates to
\texttt{1} if \texttt{x = xm};
          \item[a]

Size of the interval. Default value \texttt{1.0}. A generalized bell
evaluates to \texttt{0.5} if \texttt{x = -a} or \texttt{x = a};
          \item[b]

Measure of \emph{flatness} of the bell. The bigger the value of \texttt{b},
the flatter is the resulting function. Default value \texttt{1.0}.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_call\_\_}(\textit{self}, \textit{x})

Maps the function on a vector
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A \texttt{FuzzySet} object containing the evaluation of the function over
each of the components of the input.
      \end{quote}

    \vspace{1ex}

      Overrides: peach.fuzzy.mf.Membership.\_\_call\_\_ 	extit{(inherited documentation)}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__new__}
    \index{object.\_\_new\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{T}, \textit{S}, \textit{...})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
a new object with type S, a subtype of T
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce__}
    \index{object.\_\_reduce\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__repr__}
    \index{object.\_\_repr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__str__}
    \index{object.\_\_str\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}!peach.fuzzy.mf.Bell \textit{(class)}|)}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.mf \textit{(module)}|)}


\section{Type theoretic replacement}

\subsection{Essentially small types and maps}
It is a trivial observation, but nevertheless of fundamental importance, that by the univalence axiom the identity types of $\UU$ are equivalent to types in $\UU$, because it provides an equivalence $\eqv{(A=B)}{(\eqv{A}{B})}$, and the type $\eqv{A}{B}$ is in $\UU$ for any $A,B:\UU$. Since the identity types of $\UU$ are equivalent to types in $\UU$, we also say that the universe is \emph{locally small}.

\begin{defn}\label{defn:ess_small}
\begin{enumerate}
\item A type $A$ is said to be \define{essentially small}\index{essentially small!type|textbf} if there is a type $X:\UU$ and an equivalence $\eqv{A}{X}$. We write\index{ess_small(A)@{$\mathsf{ess\usc{}small}(A)$}|textbf}
\begin{equation*}
\mathsf{ess\usc{}small}(A)\defeq\sm{X:\UU}\eqv{A}{X}.
\end{equation*}
\item A map $f:A\to B$ is said to be \define{essentially small}\index{essentially small!map|textbf} if for each $b:B$ the fiber $\fib{f}{b}$ is essentially small.
We write\index{ess_small(f)@{$\mathsf{ess\usc{}small}(f)$}|textbf}
\begin{equation*}
\mathsf{ess\usc{}small}(f)\defeq\prd{b:B}\mathsf{ess\usc{}small}(\fib{f}{b}).
\end{equation*}
\item A type $A$ is said to be \define{locally small}\index{locally small!type} if for every $x,y:A$ the identity type $x=y$ is essentially small.
We write\index{loc_small(A)@{$\mathsf{loc\usc{}small}(A)$}|textbf}
\begin{equation*}
\mathsf{loc\usc{}small}(A)\defeq \prd{x,y:A}\mathsf{ess\usc{}small}(x=y).
\end{equation*}
\end{enumerate}
\end{defn}

\begin{lem}\label{lem:isprop_ess_small}
The type $\mathsf{ess\usc{}small}(A)$ is a proposition for any type $A$.\index{essentially small!is a proposition|textit}
\end{lem}

\begin{proof}
Let $X$ be a type. Our goal is to show that the type
\begin{equation*}
\sm{Y:\UU}\eqv{X}{Y}
\end{equation*}
is a proposition. Suppose there is a type $X':\UU$ and an equivalence $e:\eqv{X}{X'}$, then the map
\begin{equation*}
(\eqv{X}{Y})\to (\eqv{X'}{Y})
\end{equation*}
given by precomposing with $e^{-1}$ is an equivalence. This induces an equivalence on total spaces
\begin{equation*}
\eqv{\Big(\sm{Y:\UU}\eqv{X}{Y}\Big)}{\Big(\sm{Y:\UU}\eqv{X'}{Y}\Big)}
\end{equation*}
However, the codomain of this equivalence is contractible by \cref{thm:univalence}. Thus it follows by \cref{cor:contr_prop} that the asserted type is a proposition.
\end{proof}

\begin{cor}
For each function $f:A\to B$, the type $\mathsf{ess\usc{}small}(f)$ is a proposition, and for each type $X$ the type $\mathsf{loc\usc{}small}(X)$ is a proposition.
\end{cor}

\begin{proof}
This follows from the fact that propositions are closed under dependent products, established in \cref{thm:trunc_pi}.
\end{proof}

\begin{thm}\label{thm:fam_proj}
For any small type $A:\UU$ there is an equivalence
\begin{equation*}
\mathsf{map\usc{}fam}_A:\eqv{(A\to \UU)}{\Big(\sm{X:\UU} X\to A\Big)}.
\end{equation*}
\end{thm}

\begin{proof}
Note that we have the function
\begin{equation*}
\varphi :\lam{B} \Big(\sm{x:A}B(x),\proj 1\Big) : (A\to \UU)\to \Big(\sm{X:\UU}X\to A\Big).
\end{equation*}
The fiber of this map at $(X,f)$ is by univalence and function extensionality equivalent to the type
\begin{equation*}
\sm{B:A\to \UU}{e:\eqv{(\sm{x:A}B(x))}{X}} \proj 1\htpy f\circ e.
\end{equation*}
By \cref{ex:triangle_fib} this type is equivalent to the type
\begin{equation*}
\sm{B:A\to \UU}\prd{a:A} \eqv{B(a)}{\fib{f}{a}},
\end{equation*}
and by `type theoretic choice', which was established in \cref{thm:choice}, this type is equivalent to
\begin{equation*}
\prd{a:A}\sm{X:\UU}\eqv{X}{\fib{f}{a}}.
\end{equation*}
We conclude that the fiber of $\varphi$ at $(X,f)$ is equivalent to the type $\mathsf{ess\usc{}small}(f)$. However, since $f:X\to A$ is a map between small types it is essentially small. Moreover, since being essentially small is a proposition by \cref{lem:isprop_ess_small}, it follows that $\fib{\varphi}{(X,f)}$ is contractible for every $f:X\to A$. In other words, $\varphi$ is a contractible map, and therefore it is an equivalence.
\end{proof}

\begin{rmk}
The inverse of the map
\begin{equation*}
\varphi : (A\to \UU)\to \Big(\sm{X:\UU}X\to A\Big).
\end{equation*}
constructed in \cref{thm:fam_proj} is the map $(X,f)\mapsto \fibf{f}$.
\end{rmk}

\begin{thm}\label{thm:classifier}
Let $f:A\to B$ be a map. Then there is an equivalence
\begin{equation*}
\eqv{\mathsf{ess\usc{}small}(f)}{\mathsf{is\usc{}classified}(f)},
\end{equation*}
where $\mathsf{is\usc{}classified}(f)$\index{is_classified(f)@{$\mathsf{is\usc{}classified}(f)$}|textbf} is the type of quadruples $(F,\tilde{F},H,p)$ consisting of maps
$F:B\to \UU$ and $\tilde{F}:A\to \sm{X:\UU}X$, a homotopy $H:F\circ f\htpy \proj 1\circ \tilde{F}$,  such that the commuting square
\begin{equation*}
\begin{tikzcd}
A \arrow[r,"\tilde{F}"] \arrow[d,swap,"f"] & \sm{X:\UU}X \arrow[d,"\proj 1"] \\
B \arrow[r,swap,"F"] & \UU
\end{tikzcd}
\end{equation*}
is a pullback square, as witnessed by $p$\footnote{The universal property of the pullback is not expressible by a type. However, we may take the type of $p:\isequiv(h)$, where $h:A\to B\times_\UU\big(\sm{X:\UU}X\big)$ is the map obtained by the universal property of the canonical pullback.}. If $f$ comes equipped with a term of type $\mathsf{is\usc{}classified}(f)$, we also say that $f$ is \define{classified}\index{classified by the universal family|textbf} by the universal family.
\end{thm}

\begin{proof}
From \cref{ex:sq_fib} we obtain that the type of pairs $(\tilde{F},H)$ is equivalent to the type of fiberwise transformations
\begin{equation*}
\prd{b:B}\fib{f}{b}\to F(b).
\end{equation*}
By \cref{cor:pb_fibequiv} the square is a pullback square if and only if the induced map
\begin{equation*}
\prd{b:B}\fib{f}{b}\to F(b)
\end{equation*}
is a fiberwise equivalence. Thus the data $(F,\tilde{F},H,pb)$ is equivalent to the type of pairs $(F,e)$ where $e$ is a fiberwise equivalence from $\fibf{f}$ to $F$. By \cref{thm:choice} the type of pairs $(F,e)$ is equivalent to the type $\mathsf{ess\usc{}small}(f)$.
\end{proof}

\begin{rmk}
For any type $A$ (not necessarily small), and any $B:A\to \UU$, the square\index{Sigma-type@{$\Sigma$-type}!as pullback of universal family|textit}
\begin{equation*}
\begin{tikzcd}[column sep=6em]
\sm{x:A}B(x) \arrow[d,swap,"\proj 1"] \arrow[r,"{\lam{(x,y)}(B(x),y)}"] & \sm{X:\UU}X \arrow[d,"\proj 1"] \\
A \arrow[r,swap,"B"] & \UU
\end{tikzcd}
\end{equation*}
is a pullback square. Therefore it follows that for any family $B:A\to\UU$ of small types, the projection map $\proj 1:\sm{x:A}B(x)\to A$ is an essentially small map.
To see that the claim is a direct consequence of \cref{lem:pb_subst} we write the asserted square in its rudimentary form:
\begin{equation*}
%\begin{gathered}[b]
\begin{tikzcd}[column sep=6em]
\sm{x:A}\mathrm{El}(B(x)) \arrow[d,swap,"\proj 1"] \arrow[r,"{\lam{(x,y)}(B(x),y)}"] & \sm{X:\UU}\mathrm{El}(X) \arrow[d,"\proj 1"] \\
A \arrow[r,swap,"B"] & \UU.
\end{tikzcd}%\\[-\dp\strutbox]\end{gathered}\qedhere
\end{equation*}
\end{rmk}

In the following theorem we show that a type is small if and only if its diagonal is classified by $\UU$.

\begin{thm}
Let $A$ be a type. The following are equivalent:
\begin{enumerate}
\item $A$ is locally small.\index{locally small|textit}
\item There are maps $I:A\times A\to\UU$ and $\tilde{I}:A\to\sm{X:\UU}X$, and a homotopy $H:I\circ \delta_A\htpy \proj 1\circ\tilde{I}$
such that the commuting square
\begin{equation*}
\begin{tikzcd}
A \arrow[r,"\tilde{I}"] \arrow[d,swap,"\delta_A"] & \sm{X:\UU}X \arrow[d,"\proj 1"] \\
A\times A \arrow[r,swap,"{I}"] & \UU
\end{tikzcd}
\end{equation*}
is a pullback square.\index{diagonal!of a type|textit}
\end{enumerate}
\end{thm}

\begin{proof}
In \cref{ex:diagonal} we have established that the identity type $x=y$ is the fiber of $\delta_A$ at $(x,y):A\times A$. Therefore it follows that $A$ is locally small if and only if the diagonal $\delta_A$ is essentially small.
Now the result follows from \cref{thm:classifier}.
\end{proof}

\subsection{Smallness of images}

\begin{exercises}
\item
\begin{subexenum}
\item Show that any proposition is locally small.\index{proposition!is locally small}
\item Show that any essentially small type is locally small.\index{essentially small!type!is locally small}
\item Show that the function type $A\to X$ is locally small whenever $A$ is essentially small and $X$ is locally small.
\end{subexenum}
\item Let $f:A\to B$ be a map. Show that the following are equivalent:
\begin{enumerate}
\item The map $f$ is \define{locally small}\index{locally small!map|textbf} in the sense that for every $x,y:A$, the action on paths of $f$
\begin{equation*}
\apfunc{f}:(x=y)\to (f(x)=f(y))
\end{equation*}
is an essentially small map.
\item The diagonal $\delta_f$ of $f$ as defined in \cref{ex:trunc_diagonal_map} is classified by the universal fibration.
\end{enumerate}
\end{exercises}