42 DEFINE_int32(repeat, 10000,
"number of test repetitions");
77 void TestTemplatedWeights(uint64_t seed,
int repeat) {
78 WeightGenerate<TropicalWeightTpl<T>> tropical_generate(seed);
79 WeightTester<TropicalWeightTpl<T>> tropical_tester(tropical_generate);
80 tropical_tester.Test(repeat);
82 WeightGenerate<LogWeightTpl<T>> log_generate(seed);
83 WeightTester<LogWeightTpl<T>> log_tester(log_generate);
84 log_tester.Test(repeat);
86 WeightGenerate<RealWeightTpl<T>> real_generate(seed);
87 WeightTester<RealWeightTpl<T>> real_tester(real_generate);
88 real_tester.Test(repeat);
90 WeightGenerate<MinMaxWeightTpl<T>> minmax_generate(seed,
true);
91 WeightTester<MinMaxWeightTpl<T>> minmax_tester(minmax_generate);
92 minmax_tester.Test(repeat);
94 WeightGenerate<SignedLogWeightTpl<T>> signedlog_generate(seed,
true);
95 WeightTester<SignedLogWeightTpl<T>> signedlog_tester(signedlog_generate);
96 signedlog_tester.Test(repeat);
99 template <
class Weight>
100 void TestAdder(
int n) {
101 Weight sum = Weight::Zero();
103 for (
int i = 0; i < n; ++i) {
104 sum =
Plus(sum, Weight::One());
105 adder.Add(Weight::One());
110 template <
class Weight>
111 void TestSignedAdder(
int n) {
112 Weight sum = Weight::Zero();
114 const Weight minus_one =
Minus(Weight::Zero(), Weight::One());
115 for (
int i = 0; i < n; ++i) {
116 if (i < n / 4 || i > 3 * n / 4) {
117 sum =
Plus(sum, Weight::One());
118 adder.Add(Weight::One());
120 sum =
Minus(sum, Weight::One());
121 adder.Add(minus_one);
127 template <
typename Weight1,
typename Weight2>
128 void TestWeightConversion(Weight1 w1) {
130 const WeightConvert<Weight2, Weight1> to_w1_;
131 const WeightConvert<Weight1, Weight2> to_w2_;
132 Weight2 w2 = to_w2_(w1);
133 Weight1 nw1 = to_w1_(w2);
137 template <
typename FromWeight,
typename ToWeight>
138 void TestWeightCopy(FromWeight w) {
140 const ToWeight to_copied(w);
141 const FromWeight roundtrip_copied(to_copied);
145 ToWeight to_copy_assigned;
146 to_copy_assigned = w;
147 CHECK_EQ(to_copied, to_copy_assigned);
149 FromWeight roundtrip_copy_assigned;
150 roundtrip_copy_assigned = to_copy_assigned;
151 CHECK_EQ(w, roundtrip_copy_assigned);
154 template <
typename FromWeight,
typename ToWeight>
155 void TestWeightMove(FromWeight w) {
157 const FromWeight orig(w);
158 ToWeight to_moved(std::move(w));
159 const FromWeight roundtrip_moved(std::move(to_moved));
164 ToWeight to_move_assigned;
165 to_move_assigned = std::move(w);
166 FromWeight roundtrip_move_assigned;
167 roundtrip_move_assigned = std::move(to_move_assigned);
168 CHECK_EQ(orig, roundtrip_move_assigned);
171 template <
class Weight>
172 void TestImplicitConversion() {
175 CHECK(Weight(2.0f) == 2.0f);
176 CHECK(Weight(2.0) == 2.0);
177 CHECK(2.0f == Weight(2.0f));
178 CHECK(2.0 == Weight(2.0));
189 void TestPowerWeightGetSetValue() {
190 PowerWeight<LogWeight, 3> w;
198 void TestSparsePowerWeightGetSetValue() {
200 SparsePowerWeight<LogWeight> w;
201 w.SetDefaultValue(default_value);
204 CHECK_EQ(default_value, w.Value(0));
205 CHECK_EQ(default_value, w.Value(100));
243 w.SetValue(30, default_value);
244 CHECK_EQ(default_value, w.Value(30));
248 w.SetValue(5, default_value);
249 CHECK_EQ(default_value, w.Value(5));
253 w.SetValue(31, default_value);
254 w.SetValue(29, default_value);
255 w.SetValue(10, default_value);
258 CHECK_EQ(default_value, w.Value(5));
259 CHECK_EQ(default_value, w.Value(10));
260 CHECK_EQ(default_value, w.Value(29));
261 CHECK_EQ(default_value, w.Value(30));
262 CHECK_EQ(default_value, w.Value(31));
269 bool FloatEqualityIsReflexive(T m) {
273 volatile T x = 1.111;
282 void TestFloatEqualityIsReflexive() {
285 volatile double test_value = 1.1;
286 CHECK(FloatEqualityIsReflexive(static_cast<float>(test_value)));
287 CHECK(FloatEqualityIsReflexive(test_value));
292 int main(
int argc,
char **argv) {
295 TestTemplatedWeights<float>(FST_FLAGS_seed,
297 TestTemplatedWeights<double>(FST_FLAGS_seed,
299 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"()");
300 TestTemplatedWeights<float>(FST_FLAGS_seed,
302 TestTemplatedWeights<double>(FST_FLAGS_seed,
304 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"");
307 CHECK_EQ(TropicalWeight::Type(),
"tropical");
308 CHECK(TropicalWeightTpl<double>::Type() != TropicalWeightTpl<float>::Type());
310 CHECK(LogWeightTpl<double>::Type() != LogWeightTpl<float>::Type());
311 CHECK_EQ(RealWeight::Type(),
"real");
312 CHECK(RealWeightTpl<double>::Type() != RealWeightTpl<float>::Type());
313 TropicalWeightTpl<double> w(2.0);
317 TestAdder<TropicalWeight>(1000);
318 TestAdder<LogWeight>(1000);
319 TestAdder<RealWeight>(1000);
320 TestSignedAdder<SignedLogWeight>(1000);
322 TestImplicitConversion<TropicalWeight>();
323 TestImplicitConversion<LogWeight>();
324 TestImplicitConversion<RealWeight>();
325 TestImplicitConversion<MinMaxWeight>();
327 TestWeightConversion<TropicalWeight, LogWeight>(2.0);
329 using LeftStringWeight = StringWeight<int>;
330 WeightGenerate<LeftStringWeight> left_string_generate(
332 WeightTester<LeftStringWeight> left_string_tester(left_string_generate);
333 left_string_tester.Test(FST_FLAGS_repeat);
335 using RightStringWeight = StringWeight<int, STRING_RIGHT>;
336 WeightGenerate<RightStringWeight> right_string_generate(
338 WeightTester<RightStringWeight> right_string_tester(right_string_generate);
339 right_string_tester.Test(FST_FLAGS_repeat);
344 using IUSetWeight = SetWeight<int, SET_INTERSECT_UNION>;
345 WeightGenerate<IUSetWeight> iu_set_generate(FST_FLAGS_seed);
346 WeightTester<IUSetWeight> iu_set_tester(iu_set_generate);
347 iu_set_tester.Test(FST_FLAGS_repeat);
349 using UISetWeight = SetWeight<int, SET_UNION_INTERSECT>;
350 WeightGenerate<UISetWeight> ui_set_generate(FST_FLAGS_seed);
351 WeightTester<UISetWeight> ui_set_tester(ui_set_generate);
352 ui_set_tester.Test(FST_FLAGS_repeat);
357 using BoolSetWeight = SetWeight<int, SET_BOOLEAN>;
358 WeightGenerate<BoolSetWeight> bool_set_generate(FST_FLAGS_seed);
359 WeightTester<BoolSetWeight> bool_set_tester(bool_set_generate);
360 bool_set_tester.Test(FST_FLAGS_repeat);
362 TestWeightConversion<IUSetWeight, UISetWeight>(iu_set_generate());
364 TestWeightCopy<IUSetWeight, UISetWeight>(iu_set_generate());
365 TestWeightCopy<IUSetWeight, BoolSetWeight>(iu_set_generate());
366 TestWeightCopy<UISetWeight, IUSetWeight>(ui_set_generate());
367 TestWeightCopy<UISetWeight, BoolSetWeight>(ui_set_generate());
368 TestWeightCopy<BoolSetWeight, IUSetWeight>(bool_set_generate());
369 TestWeightCopy<BoolSetWeight, UISetWeight>(bool_set_generate());
371 TestWeightMove<IUSetWeight, UISetWeight>(iu_set_generate());
372 TestWeightMove<IUSetWeight, BoolSetWeight>(iu_set_generate());
373 TestWeightMove<UISetWeight, IUSetWeight>(ui_set_generate());
374 TestWeightMove<UISetWeight, BoolSetWeight>(ui_set_generate());
375 TestWeightMove<BoolSetWeight, IUSetWeight>(bool_set_generate());
376 TestWeightMove<BoolSetWeight, UISetWeight>(bool_set_generate());
380 using TropicalGallicWeight = GallicWeight<int, TropicalWeight>;
381 WeightGenerate<TropicalGallicWeight> tropical_gallic_generate(
382 FST_FLAGS_seed,
true);
383 WeightTester<TropicalGallicWeight> tropical_gallic_tester(
384 tropical_gallic_generate);
386 using TropicalGenGallicWeight = GallicWeight<int, TropicalWeight, GALLIC>;
387 WeightGenerate<TropicalGenGallicWeight> tropical_gen_gallic_generate(
388 FST_FLAGS_seed,
false);
389 WeightTester<TropicalGenGallicWeight> tropical_gen_gallic_tester(
390 tropical_gen_gallic_generate);
392 using TropicalProductWeight = ProductWeight<TropicalWeight, TropicalWeight>;
393 WeightGenerate<TropicalProductWeight> tropical_product_generate(
395 WeightTester<TropicalProductWeight> tropical_product_tester(
396 tropical_product_generate);
398 using TropicalLexicographicWeight =
399 LexicographicWeight<TropicalWeight, TropicalWeight>;
400 WeightGenerate<TropicalLexicographicWeight> tropical_lexicographic_generate(
402 WeightTester<TropicalLexicographicWeight> tropical_lexicographic_tester(
403 tropical_lexicographic_generate);
405 using TropicalCubeWeight = PowerWeight<TropicalWeight, 3>;
406 WeightGenerate<TropicalCubeWeight> tropical_cube_generate(
408 WeightTester<TropicalCubeWeight> tropical_cube_tester(tropical_cube_generate);
410 using FirstNestedProductWeight =
411 ProductWeight<TropicalProductWeight, TropicalWeight>;
412 WeightGenerate<FirstNestedProductWeight> first_nested_product_generate(
414 WeightTester<FirstNestedProductWeight> first_nested_product_tester(
415 first_nested_product_generate);
417 using SecondNestedProductWeight =
418 ProductWeight<TropicalWeight, TropicalProductWeight>;
419 WeightGenerate<SecondNestedProductWeight> second_nested_product_generate(
421 WeightTester<SecondNestedProductWeight> second_nested_product_tester(
422 second_nested_product_generate);
424 using NestedProductCubeWeight = PowerWeight<FirstNestedProductWeight, 3>;
425 WeightGenerate<NestedProductCubeWeight> nested_product_cube_generate(
427 WeightTester<NestedProductCubeWeight> nested_product_cube_tester(
428 nested_product_cube_generate);
430 using SparseNestedProductCubeWeight =
431 SparsePowerWeight<NestedProductCubeWeight, size_t>;
432 WeightGenerate<SparseNestedProductCubeWeight>
433 sparse_nested_product_cube_generate(FST_FLAGS_seed);
434 WeightTester<SparseNestedProductCubeWeight> sparse_nested_product_cube_tester(
435 sparse_nested_product_cube_generate);
437 using LogSparsePowerWeight = SparsePowerWeight<LogWeight, size_t>;
438 WeightGenerate<LogSparsePowerWeight> log_sparse_power_generate(
440 WeightTester<LogSparsePowerWeight> log_sparse_power_tester(
441 log_sparse_power_generate);
443 using LogLogExpectationWeight = ExpectationWeight<LogWeight, LogWeight>;
444 WeightGenerate<LogLogExpectationWeight> log_log_expectation_generate(
446 WeightTester<LogLogExpectationWeight> log_log_expectation_tester(
447 log_log_expectation_generate);
449 using RealRealExpectationWeight = ExpectationWeight<RealWeight, RealWeight>;
450 WeightGenerate<RealRealExpectationWeight> real_real_expectation_generate(
452 WeightTester<RealRealExpectationWeight> real_real_expectation_tester(
453 real_real_expectation_generate);
455 using LogLogSparseExpectationWeight =
456 ExpectationWeight<LogWeight, LogSparsePowerWeight>;
457 WeightGenerate<LogLogSparseExpectationWeight>
458 log_log_sparse_expectation_generate(FST_FLAGS_seed);
459 WeightTester<LogLogSparseExpectationWeight> log_log_sparse_expectation_tester(
460 log_log_sparse_expectation_generate);
462 struct UnionWeightOptions {
463 using Compare = NaturalLess<TropicalWeight>;
472 using ReverseOptions = UnionWeightOptions;
475 using TropicalUnionWeight = UnionWeight<TropicalWeight, UnionWeightOptions>;
476 WeightGenerate<TropicalUnionWeight> tropical_union_generate(
478 WeightTester<TropicalUnionWeight> tropical_union_tester(
479 tropical_union_generate);
484 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"()");
487 tropical_gallic_tester.Test(FST_FLAGS_repeat);
488 tropical_gen_gallic_tester.Test(FST_FLAGS_repeat);
489 tropical_product_tester.Test(FST_FLAGS_repeat);
490 tropical_lexicographic_tester.Test(FST_FLAGS_repeat);
491 tropical_cube_tester.Test(FST_FLAGS_repeat);
492 log_sparse_power_tester.Test(FST_FLAGS_repeat);
493 log_log_expectation_tester.Test(FST_FLAGS_repeat);
494 real_real_expectation_tester.Test(FST_FLAGS_repeat);
495 tropical_union_tester.Test(FST_FLAGS_repeat);
498 first_nested_product_tester.Test(FST_FLAGS_repeat);
499 second_nested_product_tester.Test(5);
500 nested_product_cube_tester.Test(FST_FLAGS_repeat);
501 sparse_nested_product_cube_tester.Test(FST_FLAGS_repeat);
502 log_log_sparse_expectation_tester.Test(FST_FLAGS_repeat);
505 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"");
508 tropical_gallic_tester.Test(FST_FLAGS_repeat);
509 tropical_product_tester.Test(FST_FLAGS_repeat);
510 tropical_lexicographic_tester.Test(FST_FLAGS_repeat);
511 tropical_cube_tester.Test(FST_FLAGS_repeat);
512 log_sparse_power_tester.Test(FST_FLAGS_repeat);
513 log_log_expectation_tester.Test(FST_FLAGS_repeat);
514 tropical_union_tester.Test(FST_FLAGS_repeat);
517 second_nested_product_tester.Test(FST_FLAGS_repeat);
518 log_log_sparse_expectation_tester.Test(FST_FLAGS_repeat);
520 TestPowerWeightGetSetValue();
521 TestSparsePowerWeightGetSetValue();
523 TestFloatEqualityIsReflexive();
RealWeightTpl< float > RealWeight
ErrorWeight Plus(const ErrorWeight &, const ErrorWeight &)
DEFINE_int32(repeat, 10000,"number of test repetitions")
ErrorWeight Times(const ErrorWeight &, const ErrorWeight &)
int main(int argc, char **argv)
#define SET_FLAGS(usage, argc, argv, rmflags)
LogWeightTpl< float > LogWeight
TropicalWeightTpl< float > TropicalWeight
MinMaxWeightTpl< float > MinMaxWeight
LogWeightTpl< T > Minus(const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
DEFINE_uint64(seed, 403,"random seed")
void SetFlag(Type *flag, Value value)
SignedLogWeightTpl< float > SignedLogWeight
bool ApproxEqual(const ErrorWeight &, const ErrorWeight &, float)