forked from atifrahman/HAWK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathap.h
1492 lines (1248 loc) · 51.9 KB
/
ap.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*************************************************************************
Copyright (c) Sergey Bochkanov (ALGLIB project).
>>> SOURCE LICENSE >>>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation (www.fsf.org); either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that 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.
A copy of the GNU General Public License is available at
http://www.fsf.org/licensing/licenses
>>> END OF LICENSE >>>
*************************************************************************/
#ifndef _ap_h
#define _ap_h
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string>
#include <cstring>
#include <math.h>
#ifdef __BORLANDC__
#include <list.h>
#include <vector.h>
#else
#include <list>
#include <vector>
#endif
#define AE_USE_CPP
/////////////////////////////////////////////////////////////////////////
//
// THIS SECTION CONTAINS DECLARATIONS FOR BASIC FUNCTIONALITY
// LIKE MEMORY MANAGEMENT FOR VECTORS/MATRICES WHICH IS SHARED
// BETWEEN C++ AND PURE C LIBRARIES
//
/////////////////////////////////////////////////////////////////////////
namespace alglib_impl
{
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <math.h>
#include <stddef.h>
/*
* definitions
*/
#define AE_UNKNOWN 0
#define AE_MSVC 1
#define AE_GNUC 2
#define AE_SUNC 3
#define AE_INTEL 1
#define AE_SPARC 2
#define AE_WINDOWS 1
#define AE_POSIX 2
#define AE_LOCK_ALIGNMENT 16
/*
* in case no OS is defined, use AE_UNKNOWN
*/
#ifndef AE_OS
#define AE_OS AE_UNKNOWN
#endif
/*
* automatically determine compiler
*/
#define AE_COMPILER AE_UNKNOWN
#ifdef __GNUC__
#undef AE_COMPILER
#define AE_COMPILER AE_GNUC
#endif
#if defined(__SUNPRO_C)||defined(__SUNPRO_CC)
#undef AE_COMPILER
#define AE_COMPILER AE_SUNC
#endif
#ifdef _MSC_VER
#undef AE_COMPILER
#define AE_COMPILER AE_MSVC
#endif
/*
* if we work under C++ environment, define several conditions
*/
#ifdef AE_USE_CPP
#define AE_USE_CPP_BOOL
#define AE_USE_CPP_ERROR_HANDLING
#define AE_USE_CPP_SERIALIZATION
#endif
/*
* Include SMP headers
*/
#if AE_OS==AE_WINDOWS
#include <windows.h>
#include <process.h>
#elif AE_OS==AE_POSIX
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#endif
/*
* define ae_int32_t, ae_int64_t, ae_int_t, ae_bool, ae_complex, ae_error_type and ae_datatype
*/
#if defined(AE_HAVE_STDINT)
#include <stdint.h>
#endif
#if defined(AE_INT32_T)
typedef AE_INT32_T ae_int32_t;
#endif
#if defined(AE_HAVE_STDINT) && !defined(AE_INT32_T)
typedef int32_t ae_int32_t;
#endif
#if !defined(AE_HAVE_STDINT) && !defined(AE_INT32_T)
#if AE_COMPILER==AE_MSVC
typedef _int32 ae_int32_t;
#endif
#if (AE_COMPILER==AE_GNUC) || (AE_COMPILER==AE_SUNC) || (AE_COMPILER==AE_UNKNOWN)
typedef int ae_int32_t;
#endif
#endif
#if defined(AE_INT64_T)
typedef AE_INT64_T ae_int64_t;
#endif
#if defined(AE_HAVE_STDINT) && !defined(AE_INT64_T)
typedef int64_t ae_int64_t;
#endif
#if !defined(AE_HAVE_STDINT) && !defined(AE_INT64_T)
#if AE_COMPILER==AE_MSVC
typedef _int64 ae_int64_t;
#endif
#if (AE_COMPILER==AE_GNUC) || (AE_COMPILER==AE_SUNC) || (AE_COMPILER==AE_UNKNOWN)
typedef signed long long ae_int64_t;
#endif
#endif
#if !defined(AE_INT_T)
typedef ptrdiff_t ae_int_t;
#endif
#if !defined(AE_USE_CPP_BOOL)
#define ae_bool char
#define ae_true 1
#define ae_false 0
#else
#define ae_bool bool
#define ae_true true
#define ae_false false
#endif
/*
* SSE2 intrinsics
*
* Preprocessor directives below:
* - include headers for SSE2 intrinsics
* - define AE_HAS_SSE2_INTRINSICS definition
*
* These actions are performed when we have:
* - x86 architecture definition (AE_CPU==AE_INTEL)
* - compiler which supports intrinsics
*
* Presence of AE_HAS_SSE2_INTRINSICS does NOT mean that our CPU
* actually supports SSE2 - such things should be determined at runtime
* with ae_cpuid() call. It means that we are working under Intel and
* out compiler can issue SSE2-capable code.
*
*/
#if defined(AE_CPU)
#if AE_CPU==AE_INTEL
#ifdef AE_USE_CPP
} // end of namespace declaration, subsequent includes must be out of namespace
#endif
#if AE_COMPILER==AE_MSVC
#include <emmintrin.h>
#define AE_HAS_SSE2_INTRINSICS
#endif
#if AE_COMPILER==AE_GNUC
#include <xmmintrin.h>
#define AE_HAS_SSE2_INTRINSICS
#endif
#if AE_COMPILER==AE_SUNC
#include <xmmintrin.h>
#include <emmintrin.h>
#define AE_HAS_SSE2_INTRINSICS
#endif
#ifdef AE_USE_CPP
namespace alglib_impl { // namespace declaration continued
#endif
#endif
#endif
typedef struct { double x, y; } ae_complex;
typedef enum
{
ERR_OK = 0,
ERR_OUT_OF_MEMORY = 1,
ERR_XARRAY_TOO_LARGE = 2,
ERR_ASSERTION_FAILED = 3
} ae_error_type;
typedef ae_int_t ae_datatype;
/*
* other definitions
*/
enum { OWN_CALLER=1, OWN_AE=2 };
enum { ACT_UNCHANGED=1, ACT_SAME_LOCATION=2, ACT_NEW_LOCATION=3 };
enum { DT_BOOL=1, DT_INT=2, DT_REAL=3, DT_COMPLEX=4 };
enum { CPU_SSE2=1 };
/************************************************************************
x-string (zero-terminated):
owner OWN_CALLER or OWN_AE. Determines what to do on realloc().
If vector is owned by caller, X-interface will just set
ptr to NULL before realloc(). If it is owned by X, it
will call ae_free/x_free/aligned_free family functions.
last_action ACT_UNCHANGED, ACT_SAME_LOCATION, ACT_NEW_LOCATION
contents is either: unchanged, stored at the same location,
stored at the new location.
this field is set on return from X.
ptr pointer to the actual data
Members of this structure are ae_int64_t to avoid alignment problems.
************************************************************************/
typedef struct
{
ae_int64_t owner;
ae_int64_t last_action;
char *ptr;
} x_string;
/************************************************************************
x-vector:
cnt number of elements
datatype one of the DT_XXXX values
owner OWN_CALLER or OWN_AE. Determines what to do on realloc().
If vector is owned by caller, X-interface will just set
ptr to NULL before realloc(). If it is owned by X, it
will call ae_free/x_free/aligned_free family functions.
last_action ACT_UNCHANGED, ACT_SAME_LOCATION, ACT_NEW_LOCATION
contents is either: unchanged, stored at the same location,
stored at the new location.
this field is set on return from X interface and may be
used by caller as hint when deciding what to do with data
(if it was ACT_UNCHANGED or ACT_SAME_LOCATION, no array
reallocation or copying is required).
ptr pointer to the actual data
Members of this structure are ae_int64_t to avoid alignment problems.
************************************************************************/
typedef struct
{
ae_int64_t cnt;
ae_int64_t datatype;
ae_int64_t owner;
ae_int64_t last_action;
void *ptr;
} x_vector;
/************************************************************************
x-matrix:
rows number of rows. may be zero only when cols is zero too.
cols number of columns. may be zero only when rows is zero too.
stride stride, i.e. distance between first elements of rows (in bytes)
datatype one of the DT_XXXX values
owner OWN_CALLER or OWN_AE. Determines what to do on realloc().
If vector is owned by caller, X-interface will just set
ptr to NULL before realloc(). If it is owned by X, it
will call ae_free/x_free/aligned_free family functions.
last_action ACT_UNCHANGED, ACT_SAME_LOCATION, ACT_NEW_LOCATION
contents is either: unchanged, stored at the same location,
stored at the new location.
this field is set on return from X interface and may be
used by caller as hint when deciding what to do with data
(if it was ACT_UNCHANGED or ACT_SAME_LOCATION, no array
reallocation or copying is required).
ptr pointer to the actual data, stored rowwise
Members of this structure are ae_int64_t to avoid alignment problems.
************************************************************************/
typedef struct
{
ae_int64_t rows;
ae_int64_t cols;
ae_int64_t stride;
ae_int64_t datatype;
ae_int64_t owner;
ae_int64_t last_action;
void *ptr;
} x_matrix;
/************************************************************************
dynamic block which may be automatically deallocated during stack unwinding
p_next next block in the stack unwinding list.
NULL means that this block is not in the list
deallocator deallocator function which should be used to deallocate block.
NULL for "special" blocks (frame/stack boundaries)
ptr pointer which should be passed to the deallocator.
may be null (for zero-size block), DYN_BOTTOM or DYN_FRAME
for "special" blocks (frame/stack boundaries).
************************************************************************/
typedef struct ae_dyn_block
{
struct ae_dyn_block * volatile p_next;
/* void *deallocator; */
void (*deallocator)(void*);
void * volatile ptr;
} ae_dyn_block;
/************************************************************************
frame marker
************************************************************************/
typedef struct ae_frame
{
ae_dyn_block db_marker;
} ae_frame;
/************************************************************************
ALGLIB environment state
************************************************************************/
typedef struct ae_state
{
/*
* endianness type: AE_LITTLE_ENDIAN or AE_BIG_ENDIAN
*/
ae_int_t endianness;
/*
* double value for NAN
*/
double v_nan;
/*
* double value for +INF
*/
double v_posinf;
/*
* double value for -INF
*/
double v_neginf;
/*
* pointer to the top block in a stack of frames
* which hold dynamically allocated objects
*/
ae_dyn_block * volatile p_top_block;
ae_dyn_block last_block;
/*
* jmp_buf for cases when C-style exception handling is used
*/
#ifndef AE_USE_CPP_ERROR_HANDLING
jmp_buf * volatile break_jump;
#endif
/*
* ae_error_type of the last error (filled when exception is thrown)
*/
ae_error_type volatile last_error;
/*
* human-readable message (filled when exception is thrown)
*/
const char* volatile error_msg;
/*
* threading information:
* a) current thread pool
* b) current worker thread
* c) parent task (one we are solving right now)
* d) thread exception handler (function which must be called
* by ae_assert before raising exception).
*
* NOTE: we use void* to store pointers in order to avoid explicit dependency on smp.h
*/
void *worker_thread;
void *parent_task;
void (*thread_exception_handler)(void*);
} ae_state;
/************************************************************************
Serializer
************************************************************************/
typedef struct
{
ae_int_t mode;
ae_int_t entries_needed;
ae_int_t entries_saved;
ae_int_t bytes_asked;
ae_int_t bytes_written;
#ifdef AE_USE_CPP_SERIALIZATION
std::string *out_cppstr;
#endif
char *out_str;
const char *in_str;
} ae_serializer;
typedef void(*ae_deallocator)(void*);
typedef struct ae_vector
{
ae_int_t cnt;
ae_datatype datatype;
ae_dyn_block data;
union
{
void *p_ptr;
ae_bool *p_bool;
ae_int_t *p_int;
double *p_double;
ae_complex *p_complex;
} ptr;
} ae_vector;
typedef struct ae_matrix
{
ae_int_t rows;
ae_int_t cols;
ae_int_t stride;
ae_datatype datatype;
ae_dyn_block data;
union
{
void *p_ptr;
void **pp_void;
ae_bool **pp_bool;
ae_int_t **pp_int;
double **pp_double;
ae_complex **pp_complex;
} ptr;
} ae_matrix;
typedef struct ae_smart_ptr
{
/* pointer to subscriber; all changes in ptr are translated to subscriber */
void **subscriber;
/* pointer to object */
void *ptr;
/* whether smart pointer owns ptr */
ae_bool is_owner;
/* destructor function for pointer; clears all dynamically allocated memory */
void (*destroy)(void*);
/* frame entry; used to ensure automatic deallocation of smart pointer in case of exception/exit */
ae_dyn_block frame_entry;
} ae_smart_ptr;
/*************************************************************************
Lock.
This structure provides OS-independent non-reentrant lock:
* under Windows/Posix systems it uses system-provided locks
* under Boost it uses OS-independent lock provided by Boost package
* when no OS is defined, it uses "fake lock" (just stub which is not thread-safe):
a) "fake lock" can be in locked or free mode
b) "fake lock" can be used only from one thread - one which created lock
c) when thread acquires free lock, it immediately returns
d) when thread acquires busy lock, program is terminated
(because lock is already acquired and no one else can free it)
*************************************************************************/
typedef struct
{
#if AE_OS==AE_WINDOWS
volatile ae_int_t * volatile p_lock;
char buf[sizeof(ae_int_t)+AE_LOCK_ALIGNMENT];
#elif AE_OS==AE_POSIX
pthread_mutex_t mutex;
#else
ae_bool is_locked;
#endif
} ae_lock;
/*************************************************************************
Shared pool: data structure used to provide thread-safe access to pool of
temporary variables.
*************************************************************************/
typedef struct ae_shared_pool_entry
{
void * volatile obj;
void * volatile next_entry;
} ae_shared_pool_entry;
typedef struct ae_shared_pool
{
/* lock object which protects pool */
ae_lock pool_lock;
/* seed object (used to create new instances of temporaries) */
void * volatile seed_object;
/*
* list of recycled OBJECTS:
* 1. entries in this list store pointers to recycled objects
* 2. every time we retrieve object, we retrieve first entry from this list,
* move it to recycled_entries and return its obj field to caller/
*/
ae_shared_pool_entry * volatile recycled_objects;
/*
* list of recycled ENTRIES:
* 1. this list holds entries which are not used to store recycled objects;
* every time recycled object is retrieved, its entry is moved to this list.
* 2. every time object is recycled, we try to fetch entry for him from this list
* before allocating it with malloc()
*/
ae_shared_pool_entry * volatile recycled_entries;
/* enumeration pointer, points to current recycled object*/
ae_shared_pool_entry * volatile enumeration_counter;
/* size of object; this field is used when we call malloc() for new objects */
ae_int_t size_of_object;
/* initializer function; accepts pointer to malloc'ed object, initializes its fields */
ae_bool (*init)(void* dst, ae_state* state, ae_bool make_automatic);
/* copy constructor; accepts pointer to malloc'ed, but not initialized object */
ae_bool (*init_copy)(void* dst, void* src, ae_state* state, ae_bool make_automatic);
/* destructor function; */
void (*destroy)(void* ptr);
/* frame entry; contains pointer to the pool object itself */
ae_dyn_block frame_entry;
} ae_shared_pool;
ae_int_t ae_misalignment(const void *ptr, size_t alignment);
void* ae_align(void *ptr, size_t alignment);
void* aligned_malloc(size_t size, size_t alignment);
void aligned_free(void *block);
void* ae_malloc(size_t size, ae_state *state);
void ae_free(void *p);
ae_int_t ae_sizeof(ae_datatype datatype);
void ae_touch_ptr(void *p);
void ae_state_init(ae_state *state);
void ae_state_clear(ae_state *state);
#ifndef AE_USE_CPP_ERROR_HANDLING
void ae_state_set_break_jump(ae_state *state, jmp_buf *buf);
#endif
void ae_break(ae_state *state, ae_error_type error_type, const char *msg);
void ae_frame_make(ae_state *state, ae_frame *tmp);
void ae_frame_leave(ae_state *state);
void ae_db_attach(ae_dyn_block *block, ae_state *state);
ae_bool ae_db_malloc(ae_dyn_block *block, ae_int_t size, ae_state *state, ae_bool make_automatic);
ae_bool ae_db_realloc(ae_dyn_block *block, ae_int_t size, ae_state *state);
void ae_db_free(ae_dyn_block *block);
void ae_db_swap(ae_dyn_block *block1, ae_dyn_block *block2);
ae_bool ae_vector_init(ae_vector *dst, ae_int_t size, ae_datatype datatype, ae_state *state, ae_bool make_automatic);
ae_bool ae_vector_init_copy(ae_vector *dst, ae_vector *src, ae_state *state, ae_bool make_automatic);
void ae_vector_init_from_x(ae_vector *dst, x_vector *src, ae_state *state, ae_bool make_automatic);
ae_bool ae_vector_set_length(ae_vector *dst, ae_int_t newsize, ae_state *state);
void ae_vector_clear(ae_vector *dst);
void ae_vector_destroy(ae_vector *dst);
void ae_swap_vectors(ae_vector *vec1, ae_vector *vec2);
ae_bool ae_matrix_init(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_datatype datatype, ae_state *state, ae_bool make_automatic);
ae_bool ae_matrix_init_copy(ae_matrix *dst, ae_matrix *src, ae_state *state, ae_bool make_automatic);
void ae_matrix_init_from_x(ae_matrix *dst, x_matrix *src, ae_state *state, ae_bool make_automatic);
ae_bool ae_matrix_set_length(ae_matrix *dst, ae_int_t rows, ae_int_t cols, ae_state *state);
void ae_matrix_clear(ae_matrix *dst);
void ae_matrix_destroy(ae_matrix *dst);
void ae_swap_matrices(ae_matrix *mat1, ae_matrix *mat2);
ae_bool ae_smart_ptr_init(ae_smart_ptr *dst, void **subscriber, ae_state *state, ae_bool make_automatic);
void ae_smart_ptr_clear(void *_dst); /* accepts ae_smart_ptr* */
void ae_smart_ptr_destroy(void *_dst);
void ae_smart_ptr_assign(ae_smart_ptr *dst, void *new_ptr, ae_bool is_owner, void (*destroy)(void*));
void ae_smart_ptr_release(ae_smart_ptr *dst);
void ae_init_lock(ae_lock *lock);
void ae_acquire_lock(ae_lock *lock);
void ae_release_lock(ae_lock *lock);
void ae_free_lock(ae_lock *lock);
ae_bool ae_shared_pool_init(void *_dst, ae_state *state, ae_bool make_automatic);
ae_bool ae_shared_pool_init_copy(void *_dst, void *_src, ae_state *state, ae_bool make_automatic);
void ae_shared_pool_clear(void *dst);
void ae_shared_pool_destroy(void *dst);
void ae_shared_pool_set_seed(
ae_shared_pool *dst,
void *seed_object,
ae_int_t size_of_object,
ae_bool (*init)(void* dst, ae_state* state, ae_bool make_automatic),
ae_bool (*init_copy)(void* dst, void* src, ae_state* state, ae_bool make_automatic),
void (*destroy)(void* ptr),
ae_state *state);
void ae_shared_pool_retrieve(
ae_shared_pool *pool,
ae_smart_ptr *pptr,
ae_state *state);
void ae_shared_pool_recycle(
ae_shared_pool *pool,
ae_smart_ptr *pptr,
ae_state *state);
void ae_shared_pool_clear_recycled(
ae_shared_pool *pool,
ae_state *state);
void ae_shared_pool_first_recycled(
ae_shared_pool *pool,
ae_smart_ptr *pptr,
ae_state *state);
void ae_shared_pool_next_recycled(
ae_shared_pool *pool,
ae_smart_ptr *pptr,
ae_state *state);
void ae_shared_pool_reset(
ae_shared_pool *pool,
ae_state *state);
void ae_x_set_vector(x_vector *dst, ae_vector *src, ae_state *state);
void ae_x_set_matrix(x_matrix *dst, ae_matrix *src, ae_state *state);
void ae_x_attach_to_vector(x_vector *dst, ae_vector *src);
void ae_x_attach_to_matrix(x_matrix *dst, ae_matrix *src);
void x_vector_clear(x_vector *dst);
ae_bool x_is_symmetric(x_matrix *a);
ae_bool x_is_hermitian(x_matrix *a);
ae_bool x_force_symmetric(x_matrix *a);
ae_bool x_force_hermitian(x_matrix *a);
ae_bool ae_is_symmetric(ae_matrix *a);
ae_bool ae_is_hermitian(ae_matrix *a);
ae_bool ae_force_symmetric(ae_matrix *a);
ae_bool ae_force_hermitian(ae_matrix *a);
void ae_serializer_init(ae_serializer *serializer);
void ae_serializer_clear(ae_serializer *serializer);
void ae_serializer_alloc_start(ae_serializer *serializer);
void ae_serializer_alloc_entry(ae_serializer *serializer);
ae_int_t ae_serializer_get_alloc_size(ae_serializer *serializer);
#ifdef AE_USE_CPP_SERIALIZATION
void ae_serializer_sstart_str(ae_serializer *serializer, std::string *buf);
void ae_serializer_ustart_str(ae_serializer *serializer, const std::string *buf);
#endif
void ae_serializer_sstart_str(ae_serializer *serializer, char *buf);
void ae_serializer_ustart_str(ae_serializer *serializer, const char *buf);
void ae_serializer_serialize_bool(ae_serializer *serializer, ae_bool v, ae_state *state);
void ae_serializer_serialize_int(ae_serializer *serializer, ae_int_t v, ae_state *state);
void ae_serializer_serialize_double(ae_serializer *serializer, double v, ae_state *state);
void ae_serializer_unserialize_bool(ae_serializer *serializer, ae_bool *v, ae_state *state);
void ae_serializer_unserialize_int(ae_serializer *serializer, ae_int_t *v, ae_state *state);
void ae_serializer_unserialize_double(ae_serializer *serializer, double *v, ae_state *state);
void ae_serializer_stop(ae_serializer *serializer);
/************************************************************************
Service functions
************************************************************************/
void ae_assert(ae_bool cond, const char *msg, ae_state *state);
ae_int_t ae_cpuid();
/************************************************************************
Real math functions:
* IEEE-compliant floating point comparisons
* standard functions
************************************************************************/
ae_bool ae_fp_eq(double v1, double v2);
ae_bool ae_fp_neq(double v1, double v2);
ae_bool ae_fp_less(double v1, double v2);
ae_bool ae_fp_less_eq(double v1, double v2);
ae_bool ae_fp_greater(double v1, double v2);
ae_bool ae_fp_greater_eq(double v1, double v2);
ae_bool ae_isfinite_stateless(double x, ae_int_t endianness);
ae_bool ae_isnan_stateless(double x, ae_int_t endianness);
ae_bool ae_isinf_stateless(double x, ae_int_t endianness);
ae_bool ae_isposinf_stateless(double x, ae_int_t endianness);
ae_bool ae_isneginf_stateless(double x, ae_int_t endianness);
ae_int_t ae_get_endianness();
ae_bool ae_isfinite(double x,ae_state *state);
ae_bool ae_isnan(double x, ae_state *state);
ae_bool ae_isinf(double x, ae_state *state);
ae_bool ae_isposinf(double x,ae_state *state);
ae_bool ae_isneginf(double x,ae_state *state);
double ae_fabs(double x, ae_state *state);
ae_int_t ae_iabs(ae_int_t x, ae_state *state);
double ae_sqr(double x, ae_state *state);
double ae_sqrt(double x, ae_state *state);
ae_int_t ae_sign(double x, ae_state *state);
ae_int_t ae_round(double x, ae_state *state);
ae_int_t ae_trunc(double x, ae_state *state);
ae_int_t ae_ifloor(double x, ae_state *state);
ae_int_t ae_iceil(double x, ae_state *state);
ae_int_t ae_maxint(ae_int_t m1, ae_int_t m2, ae_state *state);
ae_int_t ae_minint(ae_int_t m1, ae_int_t m2, ae_state *state);
double ae_maxreal(double m1, double m2, ae_state *state);
double ae_minreal(double m1, double m2, ae_state *state);
double ae_randomreal(ae_state *state);
ae_int_t ae_randominteger(ae_int_t maxv, ae_state *state);
double ae_sin(double x, ae_state *state);
double ae_cos(double x, ae_state *state);
double ae_tan(double x, ae_state *state);
double ae_sinh(double x, ae_state *state);
double ae_cosh(double x, ae_state *state);
double ae_tanh(double x, ae_state *state);
double ae_asin(double x, ae_state *state);
double ae_acos(double x, ae_state *state);
double ae_atan(double x, ae_state *state);
double ae_atan2(double y, double x, ae_state *state);
double ae_log(double x, ae_state *state);
double ae_pow(double x, double y, ae_state *state);
double ae_exp(double x, ae_state *state);
/************************************************************************
Complex math functions:
* basic arithmetic operations
* standard functions
************************************************************************/
ae_complex ae_complex_from_d(double v);
ae_complex ae_c_neg(ae_complex lhs);
ae_bool ae_c_eq(ae_complex lhs, ae_complex rhs);
ae_bool ae_c_neq(ae_complex lhs, ae_complex rhs);
ae_complex ae_c_add(ae_complex lhs, ae_complex rhs);
ae_complex ae_c_mul(ae_complex lhs, ae_complex rhs);
ae_complex ae_c_sub(ae_complex lhs, ae_complex rhs);
ae_complex ae_c_div(ae_complex lhs, ae_complex rhs);
ae_bool ae_c_eq_d(ae_complex lhs, double rhs);
ae_bool ae_c_neq_d(ae_complex lhs, double rhs);
ae_complex ae_c_add_d(ae_complex lhs, double rhs);
ae_complex ae_c_mul_d(ae_complex lhs, double rhs);
ae_complex ae_c_sub_d(ae_complex lhs, double rhs);
ae_complex ae_c_d_sub(double lhs, ae_complex rhs);
ae_complex ae_c_div_d(ae_complex lhs, double rhs);
ae_complex ae_c_d_div(double lhs, ae_complex rhs);
ae_complex ae_c_conj(ae_complex lhs, ae_state *state);
ae_complex ae_c_sqr(ae_complex lhs, ae_state *state);
double ae_c_abs(ae_complex z, ae_state *state);
/************************************************************************
Complex BLAS operations
************************************************************************/
ae_complex ae_v_cdotproduct(const ae_complex *v0, ae_int_t stride0, const char *conj0, const ae_complex *v1, ae_int_t stride1, const char *conj1, ae_int_t n);
void ae_v_cmove(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n);
void ae_v_cmoveneg(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n);
void ae_v_cmoved(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, double alpha);
void ae_v_cmovec(ae_complex *vdst, ae_int_t stride_dst, const ae_complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, ae_complex alpha);
void ae_v_cadd(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n);
void ae_v_caddd(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, double alpha);
void ae_v_caddc(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, ae_complex alpha);
void ae_v_csub(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n);
void ae_v_csubd(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, double alpha);
void ae_v_csubc(ae_complex *vdst, ae_int_t stride_dst, const ae_complex *vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n, ae_complex alpha);
void ae_v_cmuld(ae_complex *vdst, ae_int_t stride_dst, ae_int_t n, double alpha);
void ae_v_cmulc(ae_complex *vdst, ae_int_t stride_dst, ae_int_t n, ae_complex alpha);
/************************************************************************
Real BLAS operations
************************************************************************/
double ae_v_dotproduct(const double *v0, ae_int_t stride0, const double *v1, ae_int_t stride1, ae_int_t n);
void ae_v_move(double *vdst, ae_int_t stride_dst, const double* vsrc, ae_int_t stride_src, ae_int_t n);
void ae_v_moveneg(double *vdst, ae_int_t stride_dst, const double* vsrc, ae_int_t stride_src, ae_int_t n);
void ae_v_moved(double *vdst, ae_int_t stride_dst, const double* vsrc, ae_int_t stride_src, ae_int_t n, double alpha);
void ae_v_add(double *vdst, ae_int_t stride_dst, const double *vsrc, ae_int_t stride_src, ae_int_t n);
void ae_v_addd(double *vdst, ae_int_t stride_dst, const double *vsrc, ae_int_t stride_src, ae_int_t n, double alpha);
void ae_v_sub(double *vdst, ae_int_t stride_dst, const double *vsrc, ae_int_t stride_src, ae_int_t n);
void ae_v_subd(double *vdst, ae_int_t stride_dst, const double *vsrc, ae_int_t stride_src, ae_int_t n, double alpha);
void ae_v_muld(double *vdst, ae_int_t stride_dst, ae_int_t n, double alpha);
/************************************************************************
Other functions
************************************************************************/
ae_int_t ae_v_len(ae_int_t a, ae_int_t b);
/*
extern const double ae_machineepsilon;
extern const double ae_maxrealnumber;
extern const double ae_minrealnumber;
extern const double ae_pi;
*/
#define ae_machineepsilon 5E-16
#define ae_maxrealnumber 1E300
#define ae_minrealnumber 1E-300
#define ae_pi 3.1415926535897932384626433832795
/************************************************************************
RComm functions
************************************************************************/
typedef struct rcommstate
{
int stage;
ae_vector ia;
ae_vector ba;
ae_vector ra;
ae_vector ca;
} rcommstate;
ae_bool _rcommstate_init(rcommstate* p, ae_state *_state, ae_bool make_automatic);
ae_bool _rcommstate_init_copy(rcommstate* dst, rcommstate* src, ae_state *_state, ae_bool make_automatic);
void _rcommstate_clear(rcommstate* p);
void _rcommstate_destroy(rcommstate* p);
#ifdef AE_USE_ALLOC_COUNTER
extern ae_int64_t _alloc_counter;
#endif
/************************************************************************
debug functions (must be turned on by preprocessor definitions):
* tickcount(), which is wrapper around GetTickCount()
* flushconsole(), fluches console
* ae_debugrng(), returns random number generated with high-quality random numbers generator
* ae_set_seed(), sets seed of the debug RNG (NON-THREAD-SAFE!!!)
* ae_get_seed(), returns two seed values of the debug RNG (NON-THREAD-SAFE!!!)
************************************************************************/
#ifdef AE_DEBUG4WINDOWS
#include <windows.h>
#include <stdio.h>
#define tickcount(s) GetTickCount()
#define flushconsole(s) fflush(stdout)
#endif
#ifdef AE_DEBUG4POSIX
#define tickcount(s) PosixGetTickCount()
#define flushconsole(s) fflush(stdout)
int PosixGetTickCount();
#endif
#ifdef AE_DEBUGRNG
ae_int_t ae_debugrng();
void ae_set_seed(ae_int_t s0, ae_int_t s1);
void ae_get_seed(ae_int_t *s0, ae_int_t *s1);
#endif
}
/////////////////////////////////////////////////////////////////////////
//
// THIS SECTION CONTAINS DECLARATIONS FOR C++ RELATED FUNCTIONALITY
//
/////////////////////////////////////////////////////////////////////////
namespace alglib
{
typedef alglib_impl::ae_int_t ae_int_t;
/********************************************************************
Class forwards
********************************************************************/
class complex;
ae_int_t vlen(ae_int_t n1, ae_int_t n2);
/********************************************************************
Exception class.
********************************************************************/
class ap_error
{
public:
std::string msg;
ap_error();
ap_error(const char *s);
static void make_assertion(bool bClause);
static void make_assertion(bool bClause, const char *msg);
private:
};
/********************************************************************
Complex number with double precision.
********************************************************************/
class complex
{
public:
complex();
complex(const double &_x);
complex(const double &_x, const double &_y);
complex(const complex &z);
complex& operator= (const double& v);
complex& operator+=(const double& v);
complex& operator-=(const double& v);
complex& operator*=(const double& v);
complex& operator/=(const double& v);
complex& operator= (const complex& z);
complex& operator+=(const complex& z);
complex& operator-=(const complex& z);
complex& operator*=(const complex& z);
complex& operator/=(const complex& z);
alglib_impl::ae_complex* c_ptr();
const alglib_impl::ae_complex* c_ptr() const;
std::string tostring(int dps) const;
double x, y;
};
const alglib::complex operator/(const alglib::complex& lhs, const alglib::complex& rhs);
const bool operator==(const alglib::complex& lhs, const alglib::complex& rhs);
const bool operator!=(const alglib::complex& lhs, const alglib::complex& rhs);
const alglib::complex operator+(const alglib::complex& lhs);
const alglib::complex operator-(const alglib::complex& lhs);
const alglib::complex operator+(const alglib::complex& lhs, const alglib::complex& rhs);
const alglib::complex operator+(const alglib::complex& lhs, const double& rhs);
const alglib::complex operator+(const double& lhs, const alglib::complex& rhs);
const alglib::complex operator-(const alglib::complex& lhs, const alglib::complex& rhs);
const alglib::complex operator-(const alglib::complex& lhs, const double& rhs);
const alglib::complex operator-(const double& lhs, const alglib::complex& rhs);
const alglib::complex operator*(const alglib::complex& lhs, const alglib::complex& rhs);
const alglib::complex operator*(const alglib::complex& lhs, const double& rhs);
const alglib::complex operator*(const double& lhs, const alglib::complex& rhs);
const alglib::complex operator/(const alglib::complex& lhs, const alglib::complex& rhs);
const alglib::complex operator/(const double& lhs, const alglib::complex& rhs);
const alglib::complex operator/(const alglib::complex& lhs, const double& rhs);
double abscomplex(const alglib::complex &z);
alglib::complex conj(const alglib::complex &z);
alglib::complex csqr(const alglib::complex &z);
/********************************************************************
Level 1 BLAS functions
NOTES:
* destination and source should NOT overlap
* stride is assumed to be positive, but it is not
assert'ed within function
* conj_src parameter specifies whether complex source is conjugated
before processing or not. Pass string which starts with 'N' or 'n'
("No conj", for example) to use unmodified parameter. All other
values will result in conjugation of input, but it is recommended
to use "Conj" in such cases.
********************************************************************/
double vdotproduct(const double *v0, ae_int_t stride0, const double *v1, ae_int_t stride1, ae_int_t n);
double vdotproduct(const double *v1, const double *v2, ae_int_t N);
alglib::complex vdotproduct(const alglib::complex *v0, ae_int_t stride0, const char *conj0, const alglib::complex *v1, ae_int_t stride1, const char *conj1, ae_int_t n);
alglib::complex vdotproduct(const alglib::complex *v1, const alglib::complex *v2, ae_int_t N);
void vmove(double *vdst, ae_int_t stride_dst, const double* vsrc, ae_int_t stride_src, ae_int_t n);
void vmove(double *vdst, const double* vsrc, ae_int_t N);
void vmove(alglib::complex *vdst, ae_int_t stride_dst, const alglib::complex* vsrc, ae_int_t stride_src, const char *conj_src, ae_int_t n);
void vmove(alglib::complex *vdst, const alglib::complex* vsrc, ae_int_t N);