CUDSPMath.h

//
//  CUDSPMath.h
//  Cornell University Game Library (CUGL)
//
//  This class is represents a class of static methods for performing basic
//  DSP calculations, like addition and multiplication.  As with the DSP
//  filters, this class supports vector optimizations for SSE and Neon 64.
//  Our implementation is limited to 128-bit words.  While 256-bit (e.g. AVX)
//  are more performant, they are not better for DSP filters and so we keep
//  the optimizations at the same level.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 10/11/18
//
#ifndef __CU_DSP_MATH_H__
#define __CU_DSP_MATH_H__
#include "../CUMathBase.h"
 
namespace cugl {
    namespace dsp {
 
class DSPMath {
private:
    DSPMath() {}
    
    ~DSPMath() {}
    
    
public:
    static bool VECTORIZE;
    
#pragma mark Arithmetic Methods
 
    static size_t add(float* input1, float* input2, float* output, size_t size);
    
    static size_t multiply(float* input1, float* input2, float* output, size_t size);
 
    static size_t scale(float* input, float scalar, float* output, size_t size);
 
    static size_t scale_add(float* input1, float* input2, float scalar, float* output, size_t size);
    
#pragma mark Fade-In/Out Methods
 
    static size_t slide(float* input, float start, float end, float* output, size_t size);
    
    static size_t slide_add(float* input1, float* input2, float start, float end, float* output, size_t size);
 
#pragma mark Clamp Methods
 
    static size_t clamp(float* data, float min, float max, size_t size);
 
    static size_t ease(float* data, float bound, float knee, size_t size);
 
    // TODO: Add convolution
 
};
    }
}
#endif /* __CU_DSP_MATH_H__ */