FrameLib/Documentation/User Documentation/FrameLib_Readme.tex

%----------------------------------------------------------------------------------------
%	PACKAGES AND OTHER DOCUMENT CONFIGURATIONS
%----------------------------------------------------------------------------------------

\documentclass{article}

\usepackage{fancyhdr} % Required for custom headers
\usepackage{lastpage} % Required to determine the last page for the footer
\usepackage{extramarks} % Required for headers and footers
\usepackage{graphicx} % Required to insert images
\usepackage{datetime}
\usepackage{textcomp}
\usepackage{enumitem}
\usepackage{hyperref}

\usepackage{array}
\newcolumntype{L}[1]{>{\raggedright\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
\newcolumntype{C}[1]{>{\centering\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
\newcolumntype{R}[1]{>{\raggedleft\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}

% Margins
\topmargin=-0.45in
\evensidemargin=0in
\oddsidemargin=0in
\textwidth=6.5in
\textheight=9.0in
\headsep=0.25in 

\linespread{1.1} % Line spacing

\newcommand{\version}{Alpha 2.5}
% Set up the header and footer
\pagestyle{fancy}
\lhead{Alex Harker} % Top left header
\chead{FrameLib Documentation} % Top center header
\rhead{\version} % Top right header
\lfoot{\lastxmark} % Bottom left footer
\cfoot{} % Bottom center footer
\rfoot{Page\ \thepage\ of\ \pageref{LastPage}} % Bottom right footer
\renewcommand\headrulewidth{0.4pt} % Size of the header rule
\renewcommand\footrulewidth{0.4pt} % Size of the footer rule

%\setlength\parindent{0pt} % Removes all indentation from paragraphs

%----------------------------------------------------------------------------------------
%	DOCUMENT STRUCTURE COMMANDS
%	Skip this unless you know what you're doing
%----------------------------------------------------------------------------------------
   
%----------------------------------------------------------------------------------------
%	NAME AND CLASS SECTION
%----------------------------------------------------------------------------------------

\newcommand{\object}[1]{\textit{#1$\sim$}}
\newcommand{\flobject}[1]{\textit{fl.#1$\sim$}}
\newcommand{\flobjectb}[1]{\textbf{\flobject{#1}}}

\newcommand{\fake}[1]{\leavevmode\hphantom{#1}}
%----------------------------------------------------------------------------------------
%	TITLE PAGE
%----------------------------------------------------------------------------------------


\dmyyyydate

\title{
\vspace{2in}
\textmd{\textbf{FrameLib: \version{} Documentation}}
\vspace{0.3in}
}

\author{\textbf{Alex Harker}}
\date{Generated on \today{} at \currenttime} % Insert date here if you want it to appear below your name

%----------------------------------------------------------------------------------------

\begin{document}

\maketitle

%----------------------------------------------------------------------------------------
%	TABLE OF CONTENTS
%----------------------------------------------------------------------------------------

\newpage
\tableofcontents
\newpage

%--------------------------------------------

\section{Introduction}
\vspace{0.1in}

\subsection{Preliminaries}

This document is designed to go with alpha releases of the Max version of FrameLib (which is currently the only extant version). The documentation is currently intended to give just enough information to get experienced Max users started and and explain basic concepts, and as such is far from fully comprehensive. To install simply place the FrameLib folder in the your Packages folder. This isn't a full package install (just externals), but there is no need to create the inner folder structure manually.

\subsection{What is FrameLib?}

FrameLib is a DSP system designed to allow quick modular constructions of frame-based networks. These networks can resolve time at a highly accurate subsample level and can run at different rates, and with different frame sizes across a single network. This allows mixing of different representations (e.g. time and frequency-based representations) in a single network, efficient processing when data sizes are varying and efficient, logical expression of tightly-timed DSP constructs. The underlying C++ framework can theoretically be hosted in any block-based DSP environment, but the current user-facing version targets only Max as a set of externals. Most of you should already basically know what it is (otherwise you wouldn't be testing), so that will do for now...

\subsection{How is this an `Alpha' Version?}

In general the software should be relatively stable, but there are several items that are subject to change in terms of usage, which means \textbf{you should not use FrameLib for any large/final version projects yet!} You would do so at your own risk. The is a section later in this documentation that covers items subject to change and specific questions about these items.

\subsection{How Can I Help?}

Thanks for asking! Please comment on the usability of objects, features, points of confusion. Object ideas are also welcome, but are lower priority. Comments on the open questions in the alpha section are particularly welcome. Offers of help with documentation (or help patches) would be good, although most likely any help patches are a little way off yet. Obviously, let me know of any bugs you might find (crash logs and repeatable steps to reproduce, please). Note that the testing builds have some asserts left in, meaning that FrameLib will crash if it detects an unexpected issue - hopefully you won't have this happen, but this lets me test my assumptions `in the wild'. Developer documentation (for those wishing to write C++ objects) will come later, via doxygen, when I get to adding the relevant comment hooks (and figure out how to get doxygen to document only the things I want in the right way).
\pagebreak

%----------------------------------------------------------------------------------------

\section{Key Concepts}
\vspace{0.1in}

\subsection{Schedulers and Timing}

The most important concepts to understand in FrameLib are:

 \begin{enumerate}
\item{\textbf{Everything} is strongly timed (This timing is accurate to $2^{-64}$ of a sample).}
\item{\textbf{Nothing} happens without a timing source.}
\item{Objects that act as timing sources are called \textbf{\textit{schedulers}}.}
 \end{enumerate}

Schedulers trigger frames which then are then further processed by other objects. All FrameLib objects can accept inputs that are running at different rates (regular or irregular) and will resolve the timing between inputs correctly. Frames arriving at the same time are processed once only together. When frames arrive at different times they are processed against the latest arrivals at other inputs.

In order for your patch to do anything at all it will need at least one scheduler. You can also connect schedulers in any combination in a network and time should be resolved correctly.

Note that not all inputs to a FrameLib object will necessarily trigger processing (create output). This can vary between objects, and also over time (although this is used sparingly for specific functionality, such as the \flobject{select} object). This is seen most commonly on parameter update inputs, which are used to update object paraemters....

\subsection{Parameters}

FrameLib objects have variables with state known as parameters. Parameters are referred to by name and are used for values that may not vary over a single frame  (in this way they are unlike inputs, which are used when a value can vary over a frame). However, they may take more than one value (an array), or non-numeric values (for instance a string or a enumerator, which can be set by the name of the item, or its index number). The parameter system is used to change object behaviour, without requiring an unmanageable number of inlets, and to separate `mode' type control from normal inputs. It is somewhat akin to the Max attribute system, but it operates in the strongly-timed way that FrameLib frames do.

Parameters may be set at instantiation time, or at frame rate using tagged frames (details of how this works in Max are given in section \ref{sec:setparams}. Tagged frames are also described in more detail in \ref{sec:frametype}). Importantly, for simultaneously arriving frames where one sets parameters and others trigger processing the parameter update is performed before the processing, so updates can be performed synchronously. Some parameters are available at instantiation (usually those that set the number of inputs/outputs or pre-allocate significant memory).

Each object maintains its own set of parameters which can be detailed within Max using the inbuilt reference system (see section \ref{sec:info}).

\subsection{\label{sec:frametype}Types of Frames}

The inputs and outputs to FrameLib objects are `frames'. Frames can have two basic types in FrameLib. The first is the most common and consists of a vector of numeric values (all doubles in underlying type). The length of this vector can take any length from zero upwards (so scalars are simply a single valued frame). The frame with no values (zero length) is used as a trigger message, and has useful function (similar to a bang message in max). 

The second type of frame is a `tagged' frame. This is used primarily to transfer/set parameter values in FrameLib. A single frame can contain any number of tags (parameter names) followed by their values (of whatever type). This allows you to set multiple parameters in a single frame. Internally FrameLib has functionality for concatenating tagged frames, so it is never necessary for an object to have more than one parameter update input.  It's also possible to use tagged frames to concatenate information into a form which is easier to deal with until a point in the patch where one wishes to split the information apart again.

\subsection{Multistream Expansion}

Technically, the objects hosted in Max objects carry not single frames, but multistream connections each of which can consist of an individual stream of frames running at an independent rate and size. This is done to enable multi-resolution or multi-channel processing through a single network. If you wish you can ignore this functionality and treat each object like the inputs and outputs deal with a single stream of frames only. However, if you do wish to take advantage of this you can use the \flobject{pack} object to pack frame streams together, and \flobject{unpack} object to split them into single channel streams again. Other objects will resolve multistream inputs by internally expanding to the maximum stream count. Where there is a mismatch between different inputs the lower stream count inputs will be read modulo against the maximum count (so, for example, you can take a 16-channel input on the left of a \flobject{times} object and connect a single channel input to the right-hand side. The result will be a 16-channel output that consists of the 16 left-hand inputs all multiplied by the same right-hand stream).

You can specify the minimum number of streams regardless of the inputs by making the first argument to the object something like this:

\-\hspace{4ex} \textit{=N} where N is the minimum number of streams.\\ 
For audio objects this will determine how many copies of the audio ins/outs you see, so it can be used for multichannel IO using a single max object.
\pagebreak
%----------------------------------------------------------------------------------------

\section{Getting Started}
\vspace{0.1in}

\subsection{List of Current Schedulers}

Whilst this document is not an object reference, it is worthwhile giving more detail on the objects which act as schedulers.

\begin{description}[align=left, itemindent=3cm, labelwidth=3cm]
\item [\flobject{interval}] trigger regular frame - for irregular frames vary the interval over time.
\item [\flobject{audiotrigger}] trigger frames using MSP non-zero values
\item [\flobject{perblock}] trigger one frame per host audio block
\item [\flobject{future}] schedule frames at specific points in the future
\item [\flobject{once}] trigger one frame at the start of time, and never again
\end{description}

\subsection{Connecting Inputs and Outputs}

Only one object can be connected to a frame input. There is simply no one sensible way to combine two sets of frames in a generic manner.  When FrameLib objects are connected directly this is enforced (you are not physically able to connect two objects). When you are using abstraction or subpatching this is not possible, but you will receive an error when dsp recompiles if you've connected two objects to a single input. One output can feed any number of inputs. Feedback loops are not allowed.

\subsection{Getting Audio In and Out}

The \flobject{source} object allows you to grab chunks of audio from MSP as frames. The audio you obtain suffers a latency equal to the size of the chunk you are grabbing. For output you will commonly want a \flobject{sink} object, which acts as an overlap-add buffer to the MSP signal chain. This suffers no latency. For single value outputs as control (for instance if you want to output the values of a frequency-domain analysis back in MSP) you will probably wish to use the \flobject{trace} object.

\subsection{\label{sec:setparams}Setting Parameters}

Parameters can be set in one of two ways, either at frame rate (if the object has a Parameter Update input), or at object instantiation. At object instantiation the syntax is: \\
\-\hspace{4ex} \textit{/parameter\_name value(s) ...} \\ 
within the object box. The @ sign is not used to avoid confusion with max attributes (which show in the inspector and can be set in the max thread using messages, which FrameLib parameters cannot). In addition parameters can be assigned to a given argument number in which case they can be set from object arguments.

To set parameters at frame rate based on values in vectors, use the \flobject{tag} object to tag frames before sending them to the parameter input of an object.

\subsection{Setting Fixed Inputs}

FrameLib objects in Max support input of fixed numeric values at object instantiation that are used for any subsequent calculations, rather than values updated at frame rate. This is accessed in one of two ways. Most binary operators (e.g. \flobject{times} or \flobject{divide}) allow you to directly type the value of either input in as one or more arguments to the object (this mimics standard max object behaviour). However, as most objects use arguments to represent parameters (for ease), other objects require a special syntax for setting the value of a specific input. This is:\\
\-\hspace{4ex} \textit{[input\_number] value(s) ...} \\ 
Inputs are numbered from 1 (not zero!). You can enter vectors of any length.

\subsection{Control from Max}

As everything in max runs at frame rate you cannot just hook up max messages to control inputs. You must go through the \flobject{frommax} object. This object allows two modes of operation. In the first you can translate single numerical values or lists of numeric values into FrameLib vectors. In this case you simply pass max messages into the object. The last value(s) received will be sent as a vector when the object is triggered by a frame input.

In the second mode of operation a variable number of  inputs allow for max messages to be translated into tagged frames. In this mode each input corresponds to a named parameter, and messages send to each input will be stored until the next frame is triggered. At this point \textbf{all} stored parameter changes are sent to the output in a single concatenated frame, and cleared from the object's memory (unlike numeric vectors which will be repeated on subsequent trigger inputs).

\subsection{\label{sec:info}Getting Object Help}

There are a lot of objects and not time here to even list them. However, all objects support the \textbf{info} message. This currently prints reference type information to the max window. This is the only way to get help on individual objects, but should be compact but comprehensive.
\\ \\
Without any arguments message will print a description followed by info on inputs, outputs and parameters including ranges/enum types etc.). The operation/numbering of arguments is covered in the info text. You should note that the range and exact detail of parameters (although not the names or order) may change from one instance of an object to another. What you are receiving when you send the \textbf{info} message is technically info on the specific instance, and \textit{not} the type of object.
\\ \\
You can also use any combination of the following to customise the info given:
 
 \begin{itemize}
 \item{description (include the description)}
 \item{inputs (include info on the inputs)}
 \item{outputs  (include info on the outputs)}
 \item{io (include info on inputs and outputs)}
 \item{parameters (include info on the objects parameters)}
 \item{quick (give brief versions of all info)}
  \end{itemize}

\subsection{Code Export}

You can now get C++ code from a Max patch of FrameLib objects. For the time being this is not fully documented, but it can be done using the \textbf{export} message, which takes a class name (a symbol) and a path to write files to (another symbol). Calling this will create a C++ class that hosts its own unique FrameLib network (it can't be connected to other FrameLib) networks) and can be tied in to some other audio block-based environment. The host should create the object, call the reset method when relevant, and call the process method in the audio thread at the correct time. The object can also be polled for its number of inputs/outputs. The build should be linked against libframelib\_objects.a

Slightly more complexity is required for dealing with either buffers or sending values to/from the host. This is done via the FrameLib\_Proxy class, which can be extended for various different scenarios of usage. If you are interested in more detail on this, currently the best way to find out is to read the code on github, or email me. 

% \pagebreak

%----------------------------------------------------------------------------------------

\section{Learning More}
\vspace{0.1in}

\subsection{Demo Patches}

The demo patches supplied cover a set of simple and more complex behaviours. There is far more that you could do with FrameLib and these examples are biased towards spectral processing and granulation. These are the demos I've amassed for various presentations. They are not fully documented., but hopefully offer a solid starting point for how objects can be joined together to do something useful.

\subsection{The Objects}

A full object listing follows, grouped by function. Currently this is the best quick reference for what is included at present. For more info use the inbuilt help/info system.

\pagebreak

%----------------------------------------------------------------------------------------

\section{Current Object List}
\vspace{0.1in}

Objects in bold are yet to be finalised by review.

\renewcommand{\arraystretch}{1.2}

\subsection{Schedulers}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{audiotrigger} &
\flobjectb{perblock} &
\flobjectb{future} &
\flobjectb{interval} \\
\flobjectb{once} & 
\end{tabular}

\subsection{Unary}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{abs} &
\flobject{acosh} &
\flobject{acos} &
\flobject{asinh} \\
\flobject{asin} &
\flobject{atanh} &
\flobject{atan} &
\flobject{cbrt} \\
\flobject{ceil} &
\flobject{cosh} &
\flobject{cos} &
\flobject{erfc} \\
\flobject{erf} &
\flobject{exp2} &
\flobject{exp} &
\flobject{floor} \\
\flobject{log10} &
\flobject{log2} &
\flobject{log} &
\flobject{not} \\
\flobject{round} &
\flobject{sinh} &
\flobject{sin} &
\flobject{sqrt} \\
\flobject{tanh} &
\flobject{tan} &
\flobject{trunc}  
\end{tabular}

\subsection{Binary}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{and} &
\flobject{atan2} &
\flobject{copysign} &
\flobject{diff}\\
\flobject{divide} &
\flobject{equals} &
\flobject{greaterthaneq} &
\flobject{greaterthan} \\
\flobject{hypot} &
\flobject{lessthaneq} &
\flobject{lessthan} &
\flobject{max} \\
\flobject{minus} &
\flobject{min} &
\flobject{modulo} &
\flobject{notequals} \\
\flobject{or} &
\flobject{plus} &
\flobject{pow} &
\flobject{times} \\
\end{tabular}

\subsection{Ternary}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{clip} &
\flobjectb{fold} &
\flobjectb{wrap} &
\end{tabular}

\subsection{Complex Unary}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{cartopol} &
\flobjectb{poltocar} &
\flobjectb{complexconj} &
\flobjectb{complexcosh} \\
\flobjectb{complexcos} &
\flobjectb{complexexp} &
\flobjectb{complexlog10} &
\flobjectb{complexlog} \\
\flobjectb{complextanh} &
\flobjectb{complextan} &
\flobjectb{complexsinh} &
\flobjectb{complexsin} \\
\flobjectb{complexsqrt} &
\end{tabular}

\subsection{Complex Binary}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{complexdivide} &
\flobjectb{complexminus} &
\flobjectb{complexmultiply} &
\flobjectb{complexplus} \\
\flobjectb{complexpow} &
\end{tabular}

\subsection{Vector}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{accumpoint} &
\flobjectb{argmin} &
\flobjectb{argmax} &
\flobjectb{centroid} \\
\flobjectb{chop} &
\flobjectb{crest} &
\flobjectb{flatness} &
\flobjectb{geometricmean} \\
\flobjectb{join} &
\flobjectb{kurtosis} &
\flobjectb{length} &
\flobjectb{mean} \\
\flobjectb{medianfilter} &
\flobjectb{nanfilter} &
\flobjectb{nonzero} &
\flobjectb{pad} \\
\flobjectb{peaks} &
\flobjectb{percentile} &
\flobjectb{product} &
\flobjectb{reverse} \\
\flobjectb{rms} &
\flobjectb{shift} &
\flobjectb{skewness} &
\flobjectb{sort} \\
\flobjectb{split} &
\flobjectb{spread} &
\flobjectb{standarddeviation} &
\flobjectb{subframe} \\
\flobjectb{sum} &
\flobjectb{vmax} &
\flobjectb{vmin} &
\end{tabular}

\subsection{Generators}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{gaussian} &
\flobject{ramp} &
\flobject{random} &
\flobject{uniform}
\end{tabular}

\subsection{IO}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{sink} &
\flobject{source} &
\flobject{trace}
\end{tabular}

\subsection{Mapping}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{constant} &
\flobjectb{convert} &
\flobjectb{lookup} &
\flobjectb{map} \\
\flobjectb{samplerate}
\end{tabular}

\subsection{Host Communication}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{frommax} &
\flobjectb{tomax} &
\end{tabular}

\subsection{Buffers}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{read}
\end{tabular}

\subsection{Parameters}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{combinetags} &
\flobject{filtertags} &
\flobjectb{getparam} &
\flobject{tag} \\
\flobject{untag} &
\end{tabular}

\subsection{Routing}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{dispatch} &
\flobject{route} &
\flobject{select} &
\end{tabular}

\subsection{Streaming}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{pack} &
\flobject{streamid} &
\flobject{unpack}
\end{tabular}

\subsection{Spectral}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{convolve} &
\flobjectb{correlate} &
\flobjectb{fft} &
\flobjectb{ifft} \\
\flobjectb{multiaper} &
\flobjectb{window}
\end{tabular}

\subsection{Time Smoothing}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{ewma} &
\flobjectb{ewmsd} &
\flobjectb{framedelta} &
\flobjectb{lag} \\
\flobjectb{timestddev} &
\flobjectb{timemean} &
\flobjectb{timemedian}
\end{tabular}

\subsection{Storage}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{recall} &
\flobject{register} &
\flobject{store} \\
\end{tabular}

\subsection{Timing}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobject{now} &
\flobjectb{ticks} &
\flobject{timer} &
\flobject{timedelta} \\
\end{tabular}

\subsection{Filters}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{0dfsvf} &
\flobjectb{onepole} &
\flobjectb{onepolezero} &
\flobjectb{resonant} \\
\flobjectb{sallenkey}
\end{tabular}

\subsection{Spatial}
\begin{tabular}{L{3.8cm} L {3.8cm} L {3.8cm} L {3.8cm} }
\flobjectb{coordinatesystem} &
\flobjectb{spatial}
\end{tabular}

\pagebreak
%----------------------------------------------------------------------------------------

\section{Alpha Aspects of FrameLib}
\vspace{0.1in}

\textbf{N.B. Please note that objects not yet reviewed are more likely to change - the object list shows which objects are still due for review.}

 \begin{itemize}
\item{The object set is subject to change.}
\item{All object features are subject to change (particularly which objects have parameter inputs).}
\item{All object parameter names are subject to change. \\
 - here input on preferred formats (with or without underscores/capitals etc. would be helpful).}
\item{Notation for parameters/inputs are subject to change. \\
 - here input on preferences is appreciated.}
\item{The text displayed by the info object is subject to change. \\
 - here input on clarity/wording is appreciated. \\
 - input on what should be considered quick/comprehensive would be useful.}
  \end{itemize}
  
\pagebreak
%----------------------------------------------------------------------------------------

\section{Changes}

\subsection{Changes in Alpha 0.2}
\vspace{0.1in}

\begin{itemize}
\item Fixed documentation for FFT object outlet/inlets.
\item Fixed object info for objects using string replacement as a method for generating strings.
\item Fix for objects with no `live' inputs (no inputs that lead back to a scheduler).
\item Removed unnecessary dspchain recompiles, related to patchline re-ordering.
\end{itemize}

\subsection{Changes in Alpha 0.3}
\vspace{0.1in}

\begin{itemize}
\item Fixed testing for no live inputs to prevent crashes with audio-synced objects.
\item {[\#1 and \#14]} Fixed \flobject{medianfilter} width clipping to prevent crashes.
\item {[\#11]} Updated \flobject{fft} and \flobject{ifft} to allow complex/full spectrum FFTs and to use the new HISSTools FFT code.
\item {[\#12]} Fixed binary templates to prevent overwrites in wrap mode with mismatched input lengths.
\item {[\#15]} Fixed \flobject{source} to allow dynamic changing of the size.
\item Updated \flobject{store} now clears the buffer when audio is restarted.
\item Refactored \flobject{read} to use template based interpolation (probably requires AVX) - also allow none as a user-selectable interpolation mode.
\item Added interpolation and end behaviours to \flobject{lookup}.
\item Corrected filtering on the multi-resolution demo.
\item Fixed `wrapped' objects for patchline updates whichever end of the cable they are.
\end{itemize}

\subsection{Changes in Alpha 0.4}
\vspace{0.1in}

\begin{itemize}
\item {[\#2]} Feedback loops no longer cause crashes.
\end{itemize}

\subsection{Changes in Alpha 0.5}
\vspace{0.1in}
    
\begin{itemize}
\item {[\#18]} Fixed table reading code to account correctly for the frame size.
\item {[\#19]} Fixed crashes with empty frames into vector template objects.
\item {[\#20]} Fixed crashing with negative values into \flobject{peaks}.
.\item {[\#21]} Added the \flobject{tomax} object.
.\item Rebuilt the connection system to be shared between object types.
\end{itemize}

\subsection{Changes in Alpha 0.6}
\vspace{0.1in}

\begin{itemize}
\item {[\#7]} Objects now have channel awareness and shared memory can be channel specific.
\item {[\#13]} Added ordering connections that can take multiple connections for ordering purposes only, and also can be generated automagically.
\item {[\#22]} Fixed crash with incorrect \flobject{ifft} input size tests.
\item {[\#26]} Fixed crashes with over length lists and \flobject{tomax}.
\item {[\#26]} Fixed crashes with two inputs of length 1 into \flobject{convolve}.
\item More stringent checks for correct ordering and issues of scheduling.
\item Significant reworking of the framework for ease of use and improved design.
\item Move towards slashes for parameter entry in the max wrapper (demos changes).
\end{itemize}

\subsection{Changes in Alpha 0.7}
\vspace{0.1in}

\begin{itemize}
\item {[\#27]} Corrected median filter demo typo.
\item {[\#28]} Fixed issue with memory pool deletion on freeing of the global object.
\item Fixed double reporting of patching errors whilst audio is on.
\item Internal connection system updates and corrections (issues were currently non-visible).
\end{itemize}

\subsection{Changes in Alpha 0.8}
\vspace{0.1in}

\begin{itemize}
\item {\#29} Removed support for multiple methods for entering parameters/inputs.
\item {\#29} and {\#31} Updated binary object parameter naming scheme.
\item {\#31} Added init folder to allow aliasing to symbol-based names for binary ops.
\item {\#32} Added support for better multichannel control, including multichannel audio in and out (plus a demo patch).
\item {\#32} Minor info string updates for binary objects.
\item Added new objects (\flobject{not}, \flobject{and}, \flobject{or}, \flobject{modulo}, \flobject{channel}).
\end{itemize}

\subsection{Changes in Alpha 0.9}
\vspace{0.1in}

\begin{itemize}
\item {\#36} Changed \flobject{select} parameter naming ("num\_ins").
\item {\#38} Fixed \flobject{read} crash with non-existent buffer or buffer names including numbers.
\item Added new object \flobject{route}.
\item Added new demos for the \flobject{route} object.
\end{itemize}

\subsection{Changes in Alpha 1.0}
\vspace{0.1in}

\subsubsection{Bug fixes}

\begin{itemize}
\item {\#4} Probing on audio outs now works.
\item {\#41 and \#43} Added a parameter input to \flobject{read} and \flobject{subframe} (as well as many other objects).
\item {\#42} \flobject{modulo} now works correctly.
\item {\#45} Fixed crash with \flobject{store}.
\item \flobject{convolve} output is now scaled correctly.
\item Crash fixes for the connection system and further reworking (dependencies now handled by Max API).
\item Corrected mode setting for \flobject{lookup}.
\item Improved documentation for the \flobject{atan2} object.
\end{itemize}

\subsubsection{New objects}

\begin{itemize}
\item {\#34} New timing objects \flobject{timer}, flobject{timedelta} and \flobject{ticks} (by Francesco Cameli).
\item {\#35} New parameter objects \flobject{untag}, \flobject{filtertags}, \flobject{combinetags} and \flobject{getparam}.
\item {\#36} New routing object \flobject{dispatch}.
\item New generator object \flobject{uniform}.
\item New vector object \flobject{nonzero} (by Francesco Cameli).
\end{itemize}

\subsubsection{Renamed objects}

\begin{itemize}
\item Object \flobject{count} is renamed as \flobject{ramp}.
\item Object \flobject{channel} is renamed as \flobject{streamid}.
\item Object \flobject{setparam} is renamed as \flobject{tag}.
\end{itemize}

\subsubsection{New object features}

\begin{itemize}
\item \flobject{ramp} supports different output scalings for ease.
\item \flobject{trace} now supports different modes for which sample(s) to trace.
\item All IO objects support setting the delay at input/output.
\end{itemize}

\subsubsection{Parameter changes}

\begin{itemize}
\item Parameter naming consistent for setting number of ins/out ("num\_ins" and "num\_outs").
\item Parameter name is always "length" for output length - internal buffers use "buffer\_size".
\item IO objects have revised parameters/arguments and support units for length.
\item Generator objects have revised parameters/arguments and support units for length.
\item {\#35} Parameter objects now don't need an argument for the number of tags.
\item {\#36} Routing objects now index inputs/outputs from 1 (for consistency) and default to off/non-routed.
\item Storage objects can now deal with both vectors and tagged frames correctly.
\end{itemize}

\subsubsection{Other changes}

\begin{itemize}
\item {\#32} Multi-stream expansion syntax changed to =.
\item Binary size reduced.
\item All demos updated to reflect object changes.
\item New demos added.
\end{itemize}

\subsection{Changes in Alpha 2.0}
\vspace{0.1in}

\subsubsection{Bug fixes}

\begin{itemize}
\item {\#48} Compilation no longer requires AVX.
\item Corrected info strings for \flobject{*~},  \flobject{trace},  \flobject{constant} and  \flobject{medianfilter}
\item Corrected \flobject{length} to report zero length frames.
\item Corrected \flobject{percentile} to report the correct values.
\item Corrected \flobject{fft} to calculate FFTs with complex inputs correctly.
\item Corrected \flobject{ramp} scaling.
\item Corrected \flobject{medianfilter} edge behaviour.
\item Corrected variance calculations for  \flobject{fl.starndarddeviation} etc.
\item {\#4} Probing the outputs of FrameLib objects in Max now works.
\item {\#60} Fixed hang with \flobject{gaussian} and zero length inputs.
\item  {\#61} Fixed crash with \flobject{shift} with large shifts in padding mode.
\item FrameLib now works correctly in \object{poly~} and similar objects, even when nested.
\end{itemize}

\subsubsection{New objects}

\begin{itemize}
\item New reverse object \flobject{reverse} (by James Bradbury - {\#51}).
\item New objects to return the position of min/max values - \flobject{argmin} and \flobject{argmax} (by Owen Green).
\item New nan filtering object \flobject{nanfilter} (by Owen Green).
\item New objects for constraining values \flobject{clip}, \flobject{wrap} and \flobject{fold} (by Owen Green).
\item New gaussian random number generation object \flobject{gaussian}.
\item New correlation object \flobject{correlate}.
\item New object for calculating the sample at which a given percentage of the sum is reached \flobject{accumpoint}.
\item New complex math objects (numerous but including \flobject{cartopol} and \flobject{poltocar} as raised in {\#10}).
\item New time smoothing objects for frame delays, smoothing and statistics over time in parallel values per vector (e.g. \flobject{timemean} and \flobject{lag} as raised in {\#8}).
\end{itemize}

\subsubsection{New object features}

\begin{itemize}
\item \flobject{convolve} and  \flobject{correlate} supports real and complex inputs as well as a number of edge modes.
\item \flobject{lookup} now supports different kinds of input scaling via the "scale" parameter.
\item \flobject{sort} now supports output in the form of indices, as well as by value (see the "indices\_mode" parameter).
\item \flobject{constant} can now return an epsilon value (thanks to Owen Green).
\item {\#52} \flobject{read} now supports changing the buffer in realtime.
\end{itemize}

\subsubsection{Other changes}

\begin{itemize}
\item Corrected trigger inputs on the "clever" granular synthesis demo.
\item Corrected buffer length parameter for the  \flobject{sink} object in the "clever" granular synthesis demo.
\item Added new demos for 2D median filtering and stochastic freeze.
\item FrameLib is now compilable for pd (not quite ready for testing yet).
\item Added code export feature that can be used to auto-generate C++ code from a network in Max/pd.
\end{itemize}

\subsection{Changes in Alpha 2.5}
\vspace{0.1in}

\subsubsection{Bug fixes}

\begin{itemize}
\item {\#66} Corrected naming of not equals object.
\item Ternary objects now behave predictably for all input values.
\item Ternary objects now have info strings.
\item {\#71, \#74 and \#75} Fixed host objects (\flobject{frommax} and \flobject{tomax}) to prevent crashes.
\item  {\#64} Fixed \flobject{frommax} to copy messages sent before multistream expansion correctly to match user expectations.
\item {\#80} Corrected buffer channel setting with \flobject{read}.
\item {\#82} Fixed crash with \flobject{lookup} and empty table input.
\item {\#85} Fixed \flobject{diff} to work correctly.
\item {\#83} Fixed crash with \flobject{medianfilter} and NaNs at the input.
\item {\#69} Fixed comparison of times within FrameLib was causing mis-scheduling.
\item Fixed tagged inputs to be searched for the last occurrence of a tag to ensure the last sent tag is respected.
\item Correct patch context awareness with bpatchers and other objects.
\end{itemize}

\subsubsection{Renamed parameters}

\begin{itemize}
\item {\#62} \flobject{read} now has an "interp" parameter, rather than "mode".
\end{itemize}

\subsubsection{New features}

\begin{itemize}
\item FrameLib now has error reporting! This covers parameters as well as DSP time-out.
\end{itemize}

\subsubsection{New objects}

\begin{itemize}
\item {\#9} \flobject{expr} and \flobject{complexexpr} allow expressions in a single object.
\end{itemize}

\subsubsection{New object features}

\begin{itemize}
\item {\#59} \flobject{lookup} has a parameter input.
\item {\#56} \flobject{tag} has different modes for empty frames, with difficult behaviour being more obvious.
\end{itemize}

\subsubsection{Other changes}

\begin{itemize}
\item {\#68} FrameLib is now compiled with AVX1.0 but not AVX2.0 due to incompatibility with reasonably recent computers.
\item {\#63} Corrected typos in demos and user docs.
\item {\#77} Corrected info strings to refer to empty frames in a consistent manner.
\item {\#78} Corrected info strings to use consistent wording for the output of an object.
\item There are now tutorials and help files (massive thanks to James Bradbury).
\item What was multichannel is now multistream (as in the docs).
\item {\#76} More pd work (not quite ready for testing yet).
\end{itemize}



\end{document}