45 DEFINE_int32(repeat, 10000,
"number of test repetitions");
80 void TestTemplatedWeights(uint64_t seed,
int repeat) {
81 WeightGenerate<TropicalWeightTpl<T>> tropical_generate(seed);
82 WeightTester<TropicalWeightTpl<T>> tropical_tester(tropical_generate);
83 tropical_tester.Test(repeat);
85 WeightGenerate<LogWeightTpl<T>> log_generate(seed);
86 WeightTester<LogWeightTpl<T>> log_tester(log_generate);
87 log_tester.Test(repeat);
89 WeightGenerate<RealWeightTpl<T>> real_generate(seed);
90 WeightTester<RealWeightTpl<T>> real_tester(real_generate);
91 real_tester.Test(repeat);
93 WeightGenerate<MinMaxWeightTpl<T>> minmax_generate(seed,
true);
94 WeightTester<MinMaxWeightTpl<T>> minmax_tester(minmax_generate);
95 minmax_tester.Test(repeat);
97 WeightGenerate<SignedLogWeightTpl<T>> signedlog_generate(seed,
true);
98 WeightTester<SignedLogWeightTpl<T>> signedlog_tester(signedlog_generate);
99 signedlog_tester.Test(repeat);
102 template <
class Weight>
103 void TestAdder(
int n) {
104 Weight sum = Weight::Zero();
106 for (
int i = 0; i < n; ++i) {
107 sum =
Plus(sum, Weight::One());
108 adder.Add(Weight::One());
113 template <
class Weight>
114 void TestSignedAdder(
int n) {
115 Weight sum = Weight::Zero();
117 const Weight minus_one =
Minus(Weight::Zero(), Weight::One());
118 for (
int i = 0; i < n; ++i) {
119 if (i < n / 4 || i > 3 * n / 4) {
120 sum =
Plus(sum, Weight::One());
121 adder.Add(Weight::One());
123 sum =
Minus(sum, Weight::One());
124 adder.Add(minus_one);
130 template <
typename Weight1,
typename Weight2>
131 void TestWeightConversion(Weight1 w1) {
133 const WeightConvert<Weight2, Weight1> to_w1_;
134 const WeightConvert<Weight1, Weight2> to_w2_;
135 Weight2 w2 = to_w2_(w1);
136 Weight1 nw1 = to_w1_(w2);
140 template <
typename FromWeight,
typename ToWeight>
141 void TestWeightCopy(FromWeight w) {
143 const ToWeight to_copied(w);
144 const FromWeight roundtrip_copied(to_copied);
148 ToWeight to_copy_assigned;
149 to_copy_assigned = w;
150 CHECK_EQ(to_copied, to_copy_assigned);
152 FromWeight roundtrip_copy_assigned;
153 roundtrip_copy_assigned = to_copy_assigned;
154 CHECK_EQ(w, roundtrip_copy_assigned);
157 template <
typename FromWeight,
typename ToWeight>
158 void TestWeightMove(FromWeight w) {
160 const FromWeight orig(w);
161 ToWeight to_moved(std::move(w));
162 const FromWeight roundtrip_moved(std::move(to_moved));
167 ToWeight to_move_assigned;
168 to_move_assigned = std::move(w);
169 FromWeight roundtrip_move_assigned;
170 roundtrip_move_assigned = std::move(to_move_assigned);
171 CHECK_EQ(orig, roundtrip_move_assigned);
174 template <
class Weight>
175 void TestImplicitConversion() {
178 CHECK(Weight(2.0f) == 2.0f);
179 CHECK(Weight(2.0) == 2.0);
180 CHECK(2.0f == Weight(2.0f));
181 CHECK(2.0 == Weight(2.0));
192 void TestPowerWeightGetSetValue() {
193 PowerWeight<LogWeight, 3> w;
201 void TestSparsePowerWeightGetSetValue() {
203 SparsePowerWeight<LogWeight> w;
204 w.SetDefaultValue(default_value);
207 CHECK_EQ(default_value, w.Value(0));
208 CHECK_EQ(default_value, w.Value(100));
246 w.SetValue(30, default_value);
247 CHECK_EQ(default_value, w.Value(30));
251 w.SetValue(5, default_value);
252 CHECK_EQ(default_value, w.Value(5));
256 w.SetValue(31, default_value);
257 w.SetValue(29, default_value);
258 w.SetValue(10, default_value);
261 CHECK_EQ(default_value, w.Value(5));
262 CHECK_EQ(default_value, w.Value(10));
263 CHECK_EQ(default_value, w.Value(29));
264 CHECK_EQ(default_value, w.Value(30));
265 CHECK_EQ(default_value, w.Value(31));
272 bool FloatEqualityIsReflexive(T m) {
276 volatile T x = 1.111;
285 void TestFloatEqualityIsReflexive() {
288 volatile double test_value = 1.1;
289 CHECK(FloatEqualityIsReflexive(static_cast<float>(test_value)));
290 CHECK(FloatEqualityIsReflexive(test_value));
295 int main(
int argc,
char **argv) {
298 TestTemplatedWeights<float>(FST_FLAGS_seed,
300 TestTemplatedWeights<double>(FST_FLAGS_seed,
302 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"()");
303 TestTemplatedWeights<float>(FST_FLAGS_seed,
305 TestTemplatedWeights<double>(FST_FLAGS_seed,
307 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"");
310 CHECK_EQ(TropicalWeight::Type(),
"tropical");
311 CHECK(TropicalWeightTpl<double>::Type() != TropicalWeightTpl<float>::Type());
313 CHECK(LogWeightTpl<double>::Type() != LogWeightTpl<float>::Type());
314 CHECK_EQ(RealWeight::Type(),
"real");
315 CHECK(RealWeightTpl<double>::Type() != RealWeightTpl<float>::Type());
316 TropicalWeightTpl<double> w(2.0);
320 TestAdder<TropicalWeight>(1000);
321 TestAdder<LogWeight>(1000);
322 TestAdder<RealWeight>(1000);
323 TestSignedAdder<SignedLogWeight>(1000);
325 TestImplicitConversion<TropicalWeight>();
326 TestImplicitConversion<LogWeight>();
327 TestImplicitConversion<RealWeight>();
328 TestImplicitConversion<MinMaxWeight>();
330 TestWeightConversion<TropicalWeight, LogWeight>(2.0);
332 using LeftStringWeight = StringWeight<int>;
333 WeightGenerate<LeftStringWeight> left_string_generate(
335 WeightTester<LeftStringWeight> left_string_tester(left_string_generate);
336 left_string_tester.Test(FST_FLAGS_repeat);
338 using RightStringWeight = StringWeight<int, STRING_RIGHT>;
339 WeightGenerate<RightStringWeight> right_string_generate(
341 WeightTester<RightStringWeight> right_string_tester(right_string_generate);
342 right_string_tester.Test(FST_FLAGS_repeat);
347 using IUSetWeight = SetWeight<int, SET_INTERSECT_UNION>;
348 WeightGenerate<IUSetWeight> iu_set_generate(FST_FLAGS_seed);
349 WeightTester<IUSetWeight> iu_set_tester(iu_set_generate);
350 iu_set_tester.Test(FST_FLAGS_repeat);
352 using UISetWeight = SetWeight<int, SET_UNION_INTERSECT>;
353 WeightGenerate<UISetWeight> ui_set_generate(FST_FLAGS_seed);
354 WeightTester<UISetWeight> ui_set_tester(ui_set_generate);
355 ui_set_tester.Test(FST_FLAGS_repeat);
360 using BoolSetWeight = SetWeight<int, SET_BOOLEAN>;
361 WeightGenerate<BoolSetWeight> bool_set_generate(FST_FLAGS_seed);
362 WeightTester<BoolSetWeight> bool_set_tester(bool_set_generate);
363 bool_set_tester.Test(FST_FLAGS_repeat);
365 TestWeightConversion<IUSetWeight, UISetWeight>(iu_set_generate());
367 TestWeightCopy<IUSetWeight, UISetWeight>(iu_set_generate());
368 TestWeightCopy<IUSetWeight, BoolSetWeight>(iu_set_generate());
369 TestWeightCopy<UISetWeight, IUSetWeight>(ui_set_generate());
370 TestWeightCopy<UISetWeight, BoolSetWeight>(ui_set_generate());
371 TestWeightCopy<BoolSetWeight, IUSetWeight>(bool_set_generate());
372 TestWeightCopy<BoolSetWeight, UISetWeight>(bool_set_generate());
374 TestWeightMove<IUSetWeight, UISetWeight>(iu_set_generate());
375 TestWeightMove<IUSetWeight, BoolSetWeight>(iu_set_generate());
376 TestWeightMove<UISetWeight, IUSetWeight>(ui_set_generate());
377 TestWeightMove<UISetWeight, BoolSetWeight>(ui_set_generate());
378 TestWeightMove<BoolSetWeight, IUSetWeight>(bool_set_generate());
379 TestWeightMove<BoolSetWeight, UISetWeight>(bool_set_generate());
383 using TropicalGallicWeight = GallicWeight<int, TropicalWeight>;
384 WeightGenerate<TropicalGallicWeight> tropical_gallic_generate(
385 FST_FLAGS_seed,
true);
386 WeightTester<TropicalGallicWeight> tropical_gallic_tester(
387 tropical_gallic_generate);
389 using TropicalGenGallicWeight = GallicWeight<int, TropicalWeight, GALLIC>;
390 WeightGenerate<TropicalGenGallicWeight> tropical_gen_gallic_generate(
391 FST_FLAGS_seed,
false);
392 WeightTester<TropicalGenGallicWeight> tropical_gen_gallic_tester(
393 tropical_gen_gallic_generate);
395 using TropicalProductWeight = ProductWeight<TropicalWeight, TropicalWeight>;
396 WeightGenerate<TropicalProductWeight> tropical_product_generate(
398 WeightTester<TropicalProductWeight> tropical_product_tester(
399 tropical_product_generate);
401 using TropicalLexicographicWeight =
402 LexicographicWeight<TropicalWeight, TropicalWeight>;
403 WeightGenerate<TropicalLexicographicWeight> tropical_lexicographic_generate(
405 WeightTester<TropicalLexicographicWeight> tropical_lexicographic_tester(
406 tropical_lexicographic_generate);
408 using TropicalCubeWeight = PowerWeight<TropicalWeight, 3>;
409 WeightGenerate<TropicalCubeWeight> tropical_cube_generate(
411 WeightTester<TropicalCubeWeight> tropical_cube_tester(tropical_cube_generate);
413 using FirstNestedProductWeight =
414 ProductWeight<TropicalProductWeight, TropicalWeight>;
415 WeightGenerate<FirstNestedProductWeight> first_nested_product_generate(
417 WeightTester<FirstNestedProductWeight> first_nested_product_tester(
418 first_nested_product_generate);
420 using SecondNestedProductWeight =
421 ProductWeight<TropicalWeight, TropicalProductWeight>;
422 WeightGenerate<SecondNestedProductWeight> second_nested_product_generate(
424 WeightTester<SecondNestedProductWeight> second_nested_product_tester(
425 second_nested_product_generate);
427 using NestedProductCubeWeight = PowerWeight<FirstNestedProductWeight, 3>;
428 WeightGenerate<NestedProductCubeWeight> nested_product_cube_generate(
430 WeightTester<NestedProductCubeWeight> nested_product_cube_tester(
431 nested_product_cube_generate);
433 using SparseNestedProductCubeWeight =
434 SparsePowerWeight<NestedProductCubeWeight, size_t>;
435 WeightGenerate<SparseNestedProductCubeWeight>
436 sparse_nested_product_cube_generate(FST_FLAGS_seed);
437 WeightTester<SparseNestedProductCubeWeight> sparse_nested_product_cube_tester(
438 sparse_nested_product_cube_generate);
440 using LogSparsePowerWeight = SparsePowerWeight<LogWeight, size_t>;
441 WeightGenerate<LogSparsePowerWeight> log_sparse_power_generate(
443 WeightTester<LogSparsePowerWeight> log_sparse_power_tester(
444 log_sparse_power_generate);
446 using LogLogExpectationWeight = ExpectationWeight<LogWeight, LogWeight>;
447 WeightGenerate<LogLogExpectationWeight> log_log_expectation_generate(
449 WeightTester<LogLogExpectationWeight> log_log_expectation_tester(
450 log_log_expectation_generate);
452 using RealRealExpectationWeight = ExpectationWeight<RealWeight, RealWeight>;
453 WeightGenerate<RealRealExpectationWeight> real_real_expectation_generate(
455 WeightTester<RealRealExpectationWeight> real_real_expectation_tester(
456 real_real_expectation_generate);
458 using LogLogSparseExpectationWeight =
459 ExpectationWeight<LogWeight, LogSparsePowerWeight>;
460 WeightGenerate<LogLogSparseExpectationWeight>
461 log_log_sparse_expectation_generate(FST_FLAGS_seed);
462 WeightTester<LogLogSparseExpectationWeight> log_log_sparse_expectation_tester(
463 log_log_sparse_expectation_generate);
465 struct UnionWeightOptions {
466 using Compare = NaturalLess<TropicalWeight>;
475 using ReverseOptions = UnionWeightOptions;
478 using TropicalUnionWeight = UnionWeight<TropicalWeight, UnionWeightOptions>;
479 WeightGenerate<TropicalUnionWeight> tropical_union_generate(
481 WeightTester<TropicalUnionWeight> tropical_union_tester(
482 tropical_union_generate);
487 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"()");
490 tropical_gallic_tester.Test(FST_FLAGS_repeat);
491 tropical_gen_gallic_tester.Test(FST_FLAGS_repeat);
492 tropical_product_tester.Test(FST_FLAGS_repeat);
493 tropical_lexicographic_tester.Test(FST_FLAGS_repeat);
494 tropical_cube_tester.Test(FST_FLAGS_repeat);
495 log_sparse_power_tester.Test(FST_FLAGS_repeat);
496 log_log_expectation_tester.Test(FST_FLAGS_repeat);
497 real_real_expectation_tester.Test(FST_FLAGS_repeat);
498 tropical_union_tester.Test(FST_FLAGS_repeat);
501 first_nested_product_tester.Test(FST_FLAGS_repeat);
502 second_nested_product_tester.Test(5);
503 nested_product_cube_tester.Test(FST_FLAGS_repeat);
504 sparse_nested_product_cube_tester.Test(FST_FLAGS_repeat);
505 log_log_sparse_expectation_tester.Test(FST_FLAGS_repeat);
508 SetFlag(&FST_FLAGS_fst_weight_parentheses,
"");
511 tropical_gallic_tester.Test(FST_FLAGS_repeat);
512 tropical_product_tester.Test(FST_FLAGS_repeat);
513 tropical_lexicographic_tester.Test(FST_FLAGS_repeat);
514 tropical_cube_tester.Test(FST_FLAGS_repeat);
515 log_sparse_power_tester.Test(FST_FLAGS_repeat);
516 log_log_expectation_tester.Test(FST_FLAGS_repeat);
517 tropical_union_tester.Test(FST_FLAGS_repeat);
520 second_nested_product_tester.Test(FST_FLAGS_repeat);
521 log_log_sparse_expectation_tester.Test(FST_FLAGS_repeat);
523 TestPowerWeightGetSetValue();
524 TestSparsePowerWeightGetSetValue();
526 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)