/*
 * Support for Intel Camera Imaging ISP subsystem.
 * Copyright (c) 2015, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#ifndef __ISP_OP1W_H_INCLUDED__
#define __ISP_OP1W_H_INCLUDED__

/*
 * This file is part of the Multi-precision vector operations exstension package.
 */

/*
 * Single-precision vector operations
 */

/*
 * Prerequisites:
 *
 */
#include "storage_class.h"

#ifdef INLINE_ISP_OP1W
#define STORAGE_CLASS_ISP_OP1W_FUNC_H STORAGE_CLASS_INLINE
#define STORAGE_CLASS_ISP_OP1W_DATA_H STORAGE_CLASS_INLINE_DATA
#else /* INLINE_ISP_OP1W */
#define STORAGE_CLASS_ISP_OP1W_FUNC_H STORAGE_CLASS_EXTERN
#define STORAGE_CLASS_ISP_OP1W_DATA_H STORAGE_CLASS_EXTERN_DATA
#endif  /* INLINE_ISP_OP1W */

/*
 * Single-precision data type specification
 */

#include "isp_op1w_types.h"
#include "isp_op2w_types.h" // for doubling operations.

/*
 * Single-precision prototype specification
 */

/* Arithmetic */

/** @brief bitwise AND
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		bitwise and of both input arguments
 *
 * This function will calculate the bitwise and.
 * result = _a & _b
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_and(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief bitwise OR
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		bitwise or of both input arguments
 *
 * This function will calculate the bitwise or.
 * result = _a | _b
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_or(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief bitwise XOR
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		bitwise xor of both input arguments
 *
 * This function will calculate the bitwise xor.
 * result = _a ^ _b
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_xor(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief bitwise inverse
 *
 * @param[in] _a	first argument
 *
 * @return		bitwise inverse of both input arguments
 *
 * This function will calculate the bitwise inverse.
 * result = ~_a
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_inv(
    const tvector1w     _a);

/* Additive */

/** @brief addition
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		sum of both input arguments
 *
 * This function will calculate the sum of the input arguments.
 * in case of overflow it will wrap around.
 * result = _a + _b
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_add(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief subtraction
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_b subtracted from _a.
 *
 * This function will subtract _b from _a.
 * in case of overflow it will wrap around.
 * result = _a - _b
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_sub(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief saturated addition
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		saturated sum of both input arguments
 *
 * This function will calculate the sum of the input arguments.
 * in case of overflow it will saturate.
 * result = CLIP(_a + _b, MIN_RANGE, MAX_RANGE);
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_addsat(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief saturated subtraction
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		saturated subtraction of both input arguments
 *
 * This function will subtract _b from _a.
 * in case of overflow it will saturate.
 * result = CLIP(_a - _b, MIN_RANGE, MAX_RANGE);
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_subsat(
    const tvector1w     _a,
    const tvector1w     _b);

#ifdef ISP2401
/** @brief Unsigned saturated subtraction
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		saturated subtraction of both input arguments
 *
 * This function will subtract _b from _a.
 * in case of overflow it will saturate.
 * result = CLIP(_a - _b, 0, MAX_RANGE);
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w_unsigned OP_1w_subsat_u(
    const tvector1w_unsigned _a,
    const tvector1w_unsigned _b);

#endif
/** @brief subtraction with shift right and rounding
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		(a - b) >> 1
 *
 * This function subtracts _b from _a and right shifts
 * the result by 1 bit with rounding.
 * No overflow can occur.
 * result = (_a - _b) >> 1
 *
 * Note: This function will be deprecated due to
 * the naming confusion and it will be replaced
 * by "OP_1w_subhalfrnd".
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_subasr1(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Subtraction with shift right and rounding
 *
 * @param[in] _a	first operand
 * @param[in] _b	second operand
 *
 * @return		(_a - _b) >> 1
 *
 * This function subtracts _b from _a and right shifts
 * the result by 1 bit with rounding.
 * No overflow can occur.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_subhalfrnd(
    const tvector1w	_a,
    const tvector1w	_b);

/** @brief Subtraction with shift right and no rounding
 *
 * @param[in] _a	first operand
 * @param[in] _b	second operand
 *
 * @return		(_a - _b) >> 1
 *
 * This function subtracts _b from _a and right shifts
 * the result by 1 bit without rounding (i.e. truncation).
 * No overflow can occur.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_subhalf(
    const tvector1w	_a,
    const tvector1w	_b);


/** @brief saturated absolute value
 *
 * @param[in] _a	input
 *
 * @return		saturated absolute value of the input
 *
 * This function will calculate the saturated absolute value of the input.
 * in case of overflow it will saturate.
 * if (_a > 0) return _a;<br>
 * else return CLIP(-_a, MIN_RANGE, MAX_RANGE);<br>
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_abs(
    const tvector1w     _a);

/** @brief saturated absolute difference
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		sat(abs(a-b));
 *
 * This function will calculate the saturated absolute value
 * of the saturated difference of both inputs.
 * result = sat(abs(sat(_a - _b)));
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_subabssat(
    const tvector1w     _a,
    const tvector1w     _b);

/* Multiplicative */

/** @brief doubling multiply
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		product of _a and _b
 *
 * This function will calculate the product
 * of the input arguments and returns a double
 * precision result.
 * No overflow can occur.
 * result = _a * _b;
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector2w OP_1w_muld(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief integer multiply
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		product of _a and _b
 *
 * This function will calculate the product
 * of the input arguments and returns the LSB
 * aligned single precision result.
 * In case of overflow it will wrap around.
 * result = _a * _b;
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_mul(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief fractional saturating multiply
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		saturated product of _a and _b
 *
 * This function will calculate the fixed point
 * product of the input arguments
 * and returns a single precision result.
 * In case of overflow it will saturate.
 * FP_UNITY * FP_UNITY => FP_UNITY.
 * result = CLIP(_a * _b >> (NUM_BITS-1), MIN_RANGE, MAX_RANGE);
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_qmul(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief fractional saturating multiply with rounding
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		product of _a and _b
 *
 * This function will calculate the fixed point
 * product of the input arguments
 * and returns a single precision result.
 * FP_UNITY * FP_UNITY => FP_UNITY.
 * Depending on the rounding mode of the core
 * it will round to nearest or to nearest even.
 * result = CLIP(_a * _b >> (NUM_BITS-1), MIN_RANGE, MAX_RANGE);
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_qrmul(
    const tvector1w     _a,
    const tvector1w     _b);

/* Comparative */

/** @brief equal
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a == _b
 *
 * This function will return true if both inputs
 * are equal, and false if not equal.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_eq(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief not equal
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a != _b
 *
 * This function will return false if both inputs
 * are equal, and true if not equal.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_ne(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief less or equal
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a <= _b
 *
 * This function will return true if _a is smaller
 * or equal than _b.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_le(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief less then
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a < _b
 *
 * This function will return true if _a is smaller
 * than _b.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_lt(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief greater or equal
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a >= _b
 *
 * This function will return true if _a is greater
 * or equal than _b.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_ge(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief greater than
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a > _b
 *
 * This function will return true if _a is greater
 * than _b.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tflags OP_1w_gt(
    const tvector1w     _a,
    const tvector1w     _b);

/* Shift */

/** @brief aritmetic shift right
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a >> _b
 *
 * This function will shift _a with _b bits to the right,
 * preserving the sign bit.
 * It asserts 0 <= _b <= MAX_SHIFT_1W.
 *
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_asr(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief aritmetic shift right with rounding
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a >> _b
 *
 * If _b < NUM_BITS, this function will shift _a with _b bits to the right,
 * preserving the sign bit, and depending on the rounding mode of the core
 * it will round to nearest or to nearest even.
 * If _b >= NUM_BITS, this function will return 0.
 * It asserts 0 <= _b <= MAX_SHIFT_1W.
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_asrrnd(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief saturating arithmetic shift left
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << _b
 *
 * If _b < MAX_BITDEPTH, this function will shift _a with _b bits to the left,
 * saturating at MIN_RANGE/MAX_RANGE in case of overflow.
 * If _b >= MAX_BITDEPTH, this function will return MIN_RANGE if _a < 0,
 * MAX_RANGE if _a > 0, 0 if _a == 0.
 * (with MAX_BITDEPTH=64)
 * It asserts 0 <= _b <= MAX_SHIFT_1W.
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_asl(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief saturating aritmetic shift left
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << _b
 *
 * This function is identical to OP_1w_asl( )
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_aslsat(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief logical shift left
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << _b
 *
 * This function will shift _a with _b bits to the left.
 * It will insert zeroes on the right.
 * It asserts 0 <= _b <= MAX_SHIFT_1W.
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_lsl(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief logical shift right
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a >> _b
 *
 * This function will shift _a with _b bits to the right.
 * It will insert zeroes on the left.
 * It asserts 0 <= _b <= MAX_SHIFT_1W.
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_lsr(
    const tvector1w     _a,
    const tvector1w     _b);

#ifdef ISP2401
/** @brief bidirectional saturating arithmetic shift
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << |_b| if _b is positive
 *			_a >> |_b| if _b is negative
 *
 * If _b > 0, this function will shift _a with _b bits to the left,
 * saturating at MIN_RANGE/MAX_RANGE in case of overflow.
 * if _b < 0, this function will shift _a with _b bits to the right.
 * It asserts -MAX_SHIFT_1W <= _b <= MAX_SHIFT_1W.
 * If _b = 0, it returns _a.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_ashift_sat(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief bidirectional non-saturating arithmetic shift
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << |_b| if _b is positive
 *			_a >> |_b| if _b is negative
 *
 * If _b > 0, this function will shift _a with _b bits to the left,
 * no saturation is performed in case of overflow.
 * if _b < 0, this function will shift _a with _b bits to the right.
 * It asserts -MAX_SHIFT_1W <= _b <= MAX_SHIFT_1W.
 * If _b = 0, it returns _a.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_ashift(
    const tvector1w     _a,
    const tvector1w     _b);


/** @brief bidirectional logical shift
 *
 * @param[in] _a	input
 * @param[in] _b	shift amount
 *
 * @return		_a << |_b| if _b is positive
 *			_a >> |_b| if _b is negative
 *
 * This function will shift _a with _b bits to the left if _b is positive.
 * This function will shift _a with _b bits to the right if _b is negative.
 * It asserts -MAX_SHIFT_1W <= _b <= MAX_SHIFT_1W.
 * It inserts zeros on the left or right depending on the shift direction: 
 * right or left.
 * The operation count for this function assumes that
 * the shift amount is a cloned scalar input.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_lshift(
    const tvector1w     _a,
    const tvector1w     _b);

#endif
/* Cast */

/** @brief Cast from int to 1w
 *
 * @param[in] _a	input
 *
 * @return		_a
 *
 * This function casts the input from integer type to
 * single precision. It asserts there is no overflow.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_int_cast_to_1w(
    const int           _a);

/** @brief Cast from 1w to int
 *
 * @param[in] _a	input
 *
 * @return		_a
 *
 * This function casts the input from single precision type to
 * integer, preserving value and sign.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H int OP_1w_cast_to_int(
    const tvector1w      _a);

/** @brief Cast from 1w to 2w
 *
 * @param[in] _a	input
 *
 * @return		_a
 *
 * This function casts the input from single precision type to
 * double precision, preserving value and sign.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector2w OP_1w_cast_to_2w(
    const tvector1w     _a);

/** @brief Cast from 2w to 1w
 *
 * @param[in] _a	input
 *
 * @return		_a
 *
 * This function casts the input from double precision type to
 * single precision. In case of overflow it will wrap around.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_2w_cast_to_1w(
    const tvector2w    _a);


/** @brief Cast from 2w to 1w with saturation
 *
 * @param[in] _a	input
 *
 * @return		_a
 *
 * This function casts the input from double precision type to
 * single precision after saturating it to the range of single
 * precision.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_2w_sat_cast_to_1w(
    const tvector2w    _a);

/* clipping */

/** @brief Clip asymmetrical
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a clipped between ~_b and b
 *
 * This function will clip the first argument between
 * (-_b - 1) and _b.
 * It asserts _b >= 0.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_clip_asym(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Clip zero
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a clipped beteween 0 and _b
 *
 * This function will clip the first argument between
 * zero and _b.
 * It asserts _b >= 0.
 *
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_clipz(
    const tvector1w     _a,
    const tvector1w     _b);

/* division */

/** @brief Truncated division
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		trunc( _a / _b )
 *
 * This function will divide the first argument by
 * the second argument, with rounding toward 0.
 * If _b == 0 and _a <  0, the function will return MIN_RANGE.
 * If _b == 0 and _a == 0, the function will return 0.
 * If _b == 0 and _a >  0, the function will return MAX_RANGE.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_div(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Fractional saturating divide
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a / _b
 *
 * This function will perform fixed point division of
 * the first argument by the second argument, with rounding toward 0.
 * In case of overflow it will saturate.
 * If _b == 0 and _a <  0, the function will return MIN_RANGE.
 * If _b == 0 and _a == 0, the function will return 0.
 * If _b == 0 and _a >  0, the function will return MAX_RANGE.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_qdiv(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Modulo
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		_a % _b
 *
 * This function will return the remainder r = _a - _b * trunc( _a / _b ),
 * Note that the sign of the remainder is always equal to the sign of _a.
 * If _b == 0 the function will return _a.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_mod(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Unsigned integer Square root
 *
 * @param[in] _a	input
 *
 * @return		Integer square root of _a
 *
 * This function will calculate the Integer square root of _a
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w_unsigned OP_1w_sqrt_u(
	const tvector1w_unsigned     _a);

/* Miscellaneous */

/** @brief Multiplexer
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 * @param[in] _c	condition
 *
 * @return		_c ? _a : _b
 *
 * This function will return _a if the condition _c
 * is true and _b otherwise.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_mux(
    const tvector1w     _a,
    const tvector1w     _b,
    const tflags           _c);

/** @brief Average without rounding
 *
 * @param[in] _a	first operand
 * @param[in] _b	second operand
 *
 * @return		(_a + _b) >> 1
 *
 * This function will add _a and _b, and right shift
 * the result by one without rounding. No overflow
 * will occur because addition is performed in the
 * proper precision.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w  OP_1w_avg(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Average with rounding
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		(_a + _b) >> 1
 *
 * This function will add _a and _b at full precision,
 * and right shift with rounding the result with 1 bit.
 * Depending on the rounding mode of the core
 * it will round to nearest or to nearest even.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_avgrnd(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Minimum
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		(_a < _b) ? _a : _b;
 *
 * This function will return the smallest of both
 * input arguments.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_min(
    const tvector1w     _a,
    const tvector1w     _b);

/** @brief Maximum
 *
 * @param[in] _a	first argument
 * @param[in] _b	second argument
 *
 * @return		(_a > _b) ? _a : _b;
 *
 * This function will return the largest of both
 * input arguments.
 */
STORAGE_CLASS_ISP_OP1W_FUNC_H tvector1w OP_1w_max(
    const tvector1w     _a,
    const tvector1w     _b);

#ifndef INLINE_ISP_OP1W
#define STORAGE_CLASS_ISP_OP1W_FUNC_C
#define STORAGE_CLASS_ISP_OP1W_DATA_C const
#else /* INLINE_ISP_OP1W */
#define STORAGE_CLASS_ISP_OP1W_FUNC_C STORAGE_CLASS_ISP_OP1W_FUNC_H
#define STORAGE_CLASS_ISP_OP1W_DATA_C STORAGE_CLASS_ISP_OP1W_DATA_H
#include "isp_op1w.c"
#define ISP_OP1W_INLINED
#endif  /* INLINE_ISP_OP1W */

#endif /* __ISP_OP1W_H_INCLUDED__ */