LMMP 4.3.0
Lamina High-Precision Arithmetic Library
载入中...
搜索中...
未找到
mprand.c
浏览该文件的文档.
1/**
2 * Copyright (C) 2026 HJimmyK (Jericho Knox)
3 *
4 * This file is part of LMMP.
5 *
6 * LMMP is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 3 of
9 * the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library. If not, see
18 * <https://www.gnu.org/licenses/>.
19 *
20 * SPDX-License-Identifier: LGPL-3.0-or-later
21 */
22
23#include "lmmp/mprand.h"
24#include "impl/rand_state.h"
25#include "impl/tmp_alloc.h"
26
28
33
34#define GLOBAL_RNG_INIT_STATE 10451216379200822465ULL
35#define GLOBAL_RNG_INIT_SEED_TYPE 1
37
38void lmmp_global_rng_init_(unsigned seed, unsigned seed_type) {
39 lmmp_global_rng.state = lmmp_seed_generator(seed + seed_type);
40 lmmp_global_rng.seed_type = seed_type % 2;
41}
42
48
50 seed_type %= 2;
51 if (seed_type == 0) {
53 lmmp_pcg64_128_srandom(&rng, seed);
54 mp_size_t i = 0;
55 for (; i + 3 < n; i += 4) {
56 dst[i + 0] = lmmp_pcg64_128_random(&rng);
57 dst[i + 1] = lmmp_pcg64_128_random(&rng);
58 dst[i + 2] = lmmp_pcg64_128_random(&rng);
59 dst[i + 3] = lmmp_pcg64_128_random(&rng);
60 }
61 for (; i < n; ++i) {
62 dst[i] = lmmp_pcg64_128_random(&rng);
63 }
64 } else {
66 lmmp_xoshiro256pp_srandom(&rng, seed);
67 mp_size_t i = 0;
68 for (; i + 3 < n; i += 4) {
69 dst[i + 0] = lmmp_xoshiro256pp_random(&rng);
70 dst[i + 1] = lmmp_xoshiro256pp_random(&rng);
71 dst[i + 2] = lmmp_xoshiro256pp_random(&rng);
72 dst[i + 3] = lmmp_xoshiro256pp_random(&rng);
73 }
74 for (; i < n; ++i) {
75 dst[i] = lmmp_xoshiro256pp_random(&rng);
76 }
77 }
78 while (n > 0 && dst[n - 1] == 0) {
79 --n;
80 }
81 return n;
82}
83
85 if (n == 0 || dst == NULL) {
86 return 0;
87 }
89 seed ^= lmmp_seed_generator(n);
91 return lmmp_seed_random_(dst, n, seed, lmmp_global_rng.seed_type);
92}
93
98
100 lmmp_param_assert(k > 0);
101
103 rng->stream.k = k;
105
106 mp_limb_t new_seed = lmmp_seed_generator(seed);
107 new_seed ^= mix64(k);
108 rng->seed = new_seed;
109 pcg64_le_seq_init(&rng->stream, 0, new_seed);
110 return rng;
111}
112
114 lmmp_param_assert(rng != NULL);
115 lmmp_param_assert(k > 0);
116 if (k <= rng->stream.k) return;
117 mp_size_t old_k = rng->stream.k;
118 rng->stream.state = (mp_limb_t*)lmmp_realloc(rng->stream.state, k * sizeof(mp_limb_t));
119
120 mp_limb_t new_seed = lmmp_seed_generator(rng->stream.k);
121 new_seed ^= mix64(k + rng->seed);
122 rng->stream.k = k;
123 rng->seed = new_seed;
124 pcg64_le_seq_init(&rng->stream, old_k, new_seed);
125}
126
128 if (rng != NULL) {
129 if (rng->stream.state != NULL) {
130 lmmp_free(rng->stream.state);
131 }
132 lmmp_free(rng);
133 }
134}
135
137 lmmp_param_assert(dst != NULL);
138 lmmp_param_assert(rng != NULL);
139 lmmp_param_assert(rng->stream.state != NULL);
140 lmmp_param_assert(n > 0);
142 pcg64_le_seq_next(dst, n, &rng->stream);
143 while (n > 0 && dst[n - 1] == 0) {
144 --n;
145 }
146 return n;
147}
#define k
void * lmmp_realloc(void *ptr, size_t size)
内存重分配函数(调用lmmp_realloc_fn)
mp_limb_t * mp_ptr
定义 lmmp.h:96
uint64_t mp_size_t
定义 lmmp.h:93
void * lmmp_alloc(size_t size)
内存分配函数(调用lmmp_heap_alloc_fn)
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
uint64_t mp_limb_t
定义 lmmp.h:92
#define LMMP_VECT_CONSERVATIVE
定义 lmmp.h:201
#define LMMP_THREAD_LOCAL
定义 lmmp.h:114
#define lmmp_param_assert(x)
定义 lmmp.h:509
static __thread lmmp_global_rng_t lmmp_global_rng
#define GLOBAL_RNG_INIT_SEED_TYPE
#define GLOBAL_RNG_INIT_STATE
pcg64_le_seq_t stream
Copyright (C) 2026 HJimmyK (Jericho Knox)
mp_size_t lmmp_seed_random_(mp_ptr dst, mp_size_t n, mp_limb_t seed, unsigned seed_type)
生成随机大整数(0 - B^n-1 均匀分布)
lmmp_strong_rng_t * lmmp_strong_rng_init_(mp_size_t k, unsigned seed)
创建k维度强随机数生成器
void lmmp_strong_rng_free_(lmmp_strong_rng_t *rng)
销毁强随机数生成器
mp_size_t lmmp_strong_random_(mp_ptr dst, mp_size_t n, lmmp_strong_rng_t *rng)
生成n维度强随机数(0 - B^n-1 均匀分布)
void lmmp_global_rng_init_(unsigned seed, unsigned seed_type)
Copyright (C) 2026 HJimmyK (Jericho Knox)
void lmmp_strong_rng_extern_(lmmp_strong_rng_t *rng, mp_size_t k)
将rng内部状态拓展至k维度
mp_size_t lmmp_random_(mp_ptr dst, mp_size_t n)
生成随机大整数(0 - B^n-1 均匀分布)
#define n
static void pcg64_le_seq_init(pcg64_le_seq_t *rng, mp_size_t i, mp_limb_t seed)
mp_limb_t *restrict state
static mp_limb_t lmmp_xoshiro256pp_random(xoshiro256pp_state *rng)
static void lmmp_xoshiro256pp_srandom(xoshiro256pp_state *rng, mp_limb_t seed)
static mp_limb_t lmmp_seed_generator(mp_limb_t seed)
种子生成器
mp_limb_t lmmp_randlimb_(void)
依据全局状态获取单个随机limb(0 - B 均匀分布)
static void lmmp_pcg64_128_srandom(pcg64_128_state *rng, mp_limb_t seed)
static mp_limb_t lmmp_pcg64_128_random(pcg64_128_state *rng)
static void pcg64_le_seq_next(mp_ptr restrict dst, mp_size_t n, pcg64_le_seq_t *rng)
static mp_limb_t mix64(mp_limb_t h)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define restrict
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define ALLOC_TYPE(n, type)