legla.h

#ifndef NOSYSTEMHEADERS
#include "ltfat.h"
#ifndef _phaseret_dgtrealwrapper_h_included
#define _phaseret_dgtrealwrapper_h_included
#include "dgtrealwrapper.h"
#endif
#endif

#include "ltfat/types.h"
#include "phaseret/types.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifndef _phaseret_legla_h
#define _phaseret_legla_h
typedef struct phaseret_legla_params phaseret_legla_params;


typedef enum
{
    EXT_BOTH = (1 << 20), // << DEFAULT
    EXT_UPDOWN = (1 << 21)
} leglaupdate_ext;

typedef enum
{
    ORDER_FWD = (1 << 10), // << DEFAULT
    ORDER_REV = (1 << 11)
} leglaupdate_frameorder;

typedef struct
{
    ltfat_int height;
    ltfat_int width;
} phaseret_size;

// typedef struct
// {
//     ltfat_int y;
//     ltfat_int x;
// } phaseret_point;

typedef enum
{
    MOD_STEPWISE = (1 << 0),  // << DEFAULT
    MOD_FRAMEWISE = (1 << 1),
    MOD_COEFFICIENTWISE = (1 << 2),
    MOD_COEFFICIENTWISE_SORTED = (1 << 3),
    MOD_MODIFIEDUPDATE = (1 << 4),
} leglaupdate_mod;

PHASERET_API phaseret_legla_params*
phaseret_legla_params_allocdef();

PHASERET_API int
phaseret_legla_params_set_relthr(phaseret_legla_params* params, double relthr);

PHASERET_API int
phaseret_legla_params_set_kernelsize(phaseret_legla_params* params, phaseret_size ksize);

PHASERET_API int
phaseret_legla_params_set_leglaflags(phaseret_legla_params* params, unsigned leglaflags);

PHASERET_API phaseret_dgtreal_params*
phaseret_legla_params_get_dgtreal_params(phaseret_legla_params* params);

PHASERET_API int
phaseret_legla_params_free(phaseret_legla_params* params);

// This function is not part of API
int
phaseret_legla_params_defaults(phaseret_legla_params* params);
#endif

typedef struct PHASERET_NAME(legla_plan) PHASERET_NAME(legla_plan);
typedef struct PHASERET_NAME(leglaupdate_plan) PHASERET_NAME(leglaupdate_plan);
typedef struct PHASERET_NAME(leglaupdate_plan_col) PHASERET_NAME(leglaupdate_plan_col);


typedef int
PHASERET_NAME(legla_callback_cmod)(void* userdata, LTFAT_COMPLEX c[], ltfat_int L, ltfat_int W, ltfat_int a, ltfat_int M);

typedef int
PHASERET_NAME(legla_callback_status)(PHASERET_NAME(dgtreal_plan)* p, void* userdata, LTFAT_COMPLEX c[],
                                     ltfat_int L, ltfat_int W, ltfat_int a, ltfat_int M, double* alpha, ltfat_int iter);

PHASERET_API int
PHASERET_NAME(legla)(const LTFAT_COMPLEX cinit[], const LTFAT_REAL g[], ltfat_int L, ltfat_int gl,
                     ltfat_int W, ltfat_int a, ltfat_int M, ltfat_int iter, LTFAT_COMPLEX c[]);

PHASERET_API int
PHASERET_NAME(legla_init)(const LTFAT_COMPLEX cinit[], const LTFAT_REAL g[], ltfat_int L,
                          ltfat_int gl, ltfat_int W, ltfat_int a, ltfat_int M,
                          const double alpha, LTFAT_COMPLEX c[],
                          phaseret_legla_params* params, PHASERET_NAME(legla_plan)** p);



PHASERET_API int
PHASERET_NAME(legla_execute)(PHASERET_NAME(legla_plan)* p, ltfat_int iter);

PHASERET_API int
PHASERET_NAME(legla_execute_newarray)(PHASERET_NAME(legla_plan)* p,
                                      const LTFAT_COMPLEX cinit[],
                                      ltfat_int iter, LTFAT_COMPLEX c[]);

PHASERET_API int
PHASERET_NAME(legla_done)(PHASERET_NAME(legla_plan)** p);

PHASERET_API int
PHASERET_NAME(legla_set_status_callback)(PHASERET_NAME(legla_plan)* p,
        PHASERET_NAME(legla_callback_status)* callback, void* userdata);

PHASERET_API int
PHASERET_NAME(legla_set_cmod_callback)(PHASERET_NAME(legla_plan)* p,
                                       PHASERET_NAME(legla_callback_cmod)* callback,
                                       void* userdata);

/* Single iteration  */
int
PHASERET_NAME(leglaupdate_init)(const LTFAT_COMPLEX kern[], phaseret_size ksize,
                                ltfat_int L, ltfat_int W, ltfat_int a, ltfat_int M, ltfat_int flags,
                                PHASERET_NAME(leglaupdate_plan)** pout);

extern void
PHASERET_NAME(leglaupdate_execute)(PHASERET_NAME(leglaupdate_plan)* plan,
                                   const LTFAT_REAL s[], LTFAT_COMPLEX c[],
                                   LTFAT_COMPLEX cout[]);

void
PHASERET_NAME(leglaupdate_done)(PHASERET_NAME(leglaupdate_plan)** plan);

/* Single col update */
int
PHASERET_NAME(leglaupdate_col_init)(ltfat_int M, phaseret_size ksize, int flags,
                                    PHASERET_NAME(leglaupdate_plan_col)** pout);

int
PHASERET_NAME(leglaupdate_col_done)( PHASERET_NAME(leglaupdate_plan_col)** p);

void
PHASERET_NAME(leglaupdate_col_execute)(
    PHASERET_NAME(leglaupdate_plan_col)* plan,
    const LTFAT_REAL sCol[],
    const LTFAT_COMPLEX actK[],
    LTFAT_COMPLEX cColFirst[],
    LTFAT_COMPLEX coutrCol[]);

/* Utils */
void
PHASERET_NAME(extendborders)(PHASERET_NAME(leglaupdate_plan_col)* plan,
                             const LTFAT_COMPLEX c[], ltfat_int N, LTFAT_COMPLEX buf[]);

int
PHASERET_NAME(legla_big2small_kernel)(LTFAT_COMPLEX* bigc, phaseret_size bigsize,
                                      phaseret_size smallsize, LTFAT_COMPLEX* smallc);

int
PHASERET_NAME(legla_findkernelsize)(LTFAT_COMPLEX* bigc, phaseret_size bigsize,
                                    double relthr, phaseret_size* ksize);

/* Modulate kernel */
void
PHASERET_NAME(kernphasefi)(const LTFAT_COMPLEX kern[], phaseret_size ksize,
                           ltfat_int n, ltfat_int a, ltfat_int M, LTFAT_COMPLEX kernmod[]);

/* Format kernel */
void
PHASERET_NAME(formatkernel)(LTFAT_REAL* kernr, LTFAT_REAL* kerni,
                            ltfat_int kernh, ltfat_int kernw,
                            ltfat_int kernwskip, LTFAT_REAL* kernmodr, LTFAT_REAL* kernmodi);



#ifdef __cplusplus
}
#endif