opencog-atomspace / tests / atoms / flow / FormulaUTest.cxxtest

/*
 * tests/atoms/flow/FormulaUTest.cxxtest
 *
 * Copyright (C) 2019 Linas Vepstas
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

#include <string>
#include <math.h>
#include <opencog/guile/SchemeEval.h>
#include <opencog/atoms/base/Atom.h>
#include <opencog/atoms/core/NumberNode.h>
#include <opencog/atomspace/AtomSpace.h>
#include <opencog/atoms/value/BoolValue.h>

#include <cxxtest/TestSuite.h>

using namespace opencog;

class FormulaUTest :  public CxxTest::TestSuite
{
private:
	AtomSpacePtr _asp;
	SchemeEval* _eval;

public:
	FormulaUTest() : _asp(createAtomSpace()), _eval(SchemeEval::get_scheme_evaluator(_asp))
	{
		logger().set_timestamp_flag(false);
		logger().set_print_to_stdout_flag(true);

		_eval->eval("(add-to-load-path \"" PROJECT_SOURCE_DIR "\")");
		_eval->eval("(load-from-path \"tests/atoms/flow/formulas.scm\")");
	}

	void setUp() {}

	void tearDown() {}

	void test_strength_of();
	void test_formula();
	void test_evalform();
	void test_define();
	void test_lambda();
	void test_defined_true();
};

#define MAXERR 1.0e-12

void FormulaUTest::test_strength_of()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	_eval->eval("(cog-set-value! atom-a tvkey (FloatValue 0.8 1.0))");
	_eval->eval("(cog-set-value! atom-b tvkey (FloatValue 0.6 0.9))");

	ValuePtr sof = _eval->eval_v("(cog-execute! (strength-of (Concept \"A\")))");
	printf("Get strength_of=%s\n", sof->to_string().c_str());
	TS_ASSERT_EQUALS(sof->get_type(), FLOAT_VALUE);
	FloatValuePtr fvp = FloatValueCast(sof);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.8), MAXERR);

	ValuePtr cof = _eval->eval_v("(cog-execute! (confidence-of (Concept \"B\")))");
	printf("Get conf_of=%s\n", cof->to_string().c_str());
	TS_ASSERT_EQUALS(cof->get_type(), FLOAT_VALUE);
	fvp = FloatValueCast(cof);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.9), MAXERR);

	ValuePtr pof = _eval->eval_v("(cog-execute! prod)");
	printf("Get product=%s\n", pof->to_string().c_str());
	TS_ASSERT_EQUALS(pof->get_type(), FLOAT_VALUE);
	fvp = FloatValueCast(pof);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.48), MAXERR);

	logger().info("END TEST: %s", __FUNCTION__);
}

void FormulaUTest::test_formula()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	ValuePtr tvp = _eval->eval_v("(cog-execute! formula-stv)");
	printf("Get formula-stv=%s\n", tvp->to_string().c_str());
	TS_ASSERT_EQUALS(tvp->get_type(), FLOAT_VALUE);
	FloatValuePtr fvp = FloatValueCast(tvp);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.52), MAXERR);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[1] - 0.9), MAXERR);

	logger().info("END TEST: %s", __FUNCTION__);
}

void FormulaUTest::test_evalform()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	ValuePtr tvp = _eval->eval_v("(cog-execute! eval-formula)");
	printf("Get eval-formula=%s\n", tvp->to_string().c_str());
	TS_ASSERT_EQUALS(tvp->get_type(), FLOAT_VALUE);
	FloatValuePtr fvp = FloatValueCast(tvp);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.52), MAXERR);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[1] - 0.9), MAXERR);

	logger().info("END TEST: %s", __FUNCTION__);
}

void FormulaUTest::test_define()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	// --------------
	_eval->eval("(cog-set-value! atom-a tvkey (FloatValue 0.3 0.5))");
	_eval->eval("(cog-set-value! atom-b tvkey (FloatValue 0.4 0.5))");

	ValuePtr tvp = _eval->eval_v("(cog-execute! red-form)");
	printf("New red-form=%s\n", tvp->to_string().c_str());
	TS_ASSERT_EQUALS(tvp->get_type(), FLOAT_VALUE);
	FloatValuePtr fvp = FloatValueCast(tvp);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.88), MAXERR);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[1] - 0.25), MAXERR);

	// --------------
	_eval->eval("(cog-set-value! atom-a tvkey (FloatValue 0.2 0.98))");
	_eval->eval("(cog-set-value! atom-b tvkey (FloatValue 0.2 0.98))");

	tvp = _eval->eval_v("(cog-execute! red-form)");
	printf("New red-form=%s\n", tvp->to_string().c_str());
	TS_ASSERT_EQUALS(tvp->get_type(), FLOAT_VALUE);
	fvp = FloatValueCast(tvp);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[0] - 0.96), MAXERR);
	TS_ASSERT_LESS_THAN(fabs(fvp->value()[1] - 0.9604), MAXERR);

	logger().info("END TEST: %s", __FUNCTION__);
}

void FormulaUTest::test_lambda()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	ValuePtr vp = _eval->eval_v("(cog-execute! (its-one atom-a atom-b))");
	printf("Value for iab=%s\n", vp->to_string().c_str());
	TS_ASSERT_EQUALS(vp->get_type(), BOOL_VALUE);
	BoolValuePtr bvp = BoolValueCast(vp);
	TS_ASSERT(bvp->get_bit(0));

	vp = _eval->eval_v("(cog-execute! (its-one atom-b atom-c))");
	printf("Value for ibc=%s\n", vp->to_string().c_str());
	TS_ASSERT_EQUALS(vp->get_type(), BOOL_VALUE);
	bvp = BoolValueCast(vp);
	TS_ASSERT(not bvp->get_bit(0));

	vp = _eval->eval_v("(cog-execute! (its-conf atom-a atom-b))");
	printf("Value for iab=%s\n", vp->to_string().c_str());
	TS_ASSERT_EQUALS(vp->get_type(), BOOL_VALUE);
	bvp = BoolValueCast(vp);
	TS_ASSERT(bvp->get_bit(0));

	vp = _eval->eval_v("(cog-execute! (its-conf atom-b atom-c))");
	printf("Value for ibc=%s\n", vp->to_string().c_str());
	TS_ASSERT_EQUALS(vp->get_type(), BOOL_VALUE);
	bvp = BoolValueCast(vp);
	TS_ASSERT(not bvp->get_bit(0));

	logger().info("END TEST: %s", __FUNCTION__);
}

void FormulaUTest::test_defined_true()
{
	logger().info("BEGIN TEST: %s", __FUNCTION__);

	for (double acc=0.0; acc < 10.5; acc += 1.0)
	{
		Handle hsum = _eval->eval_h("(get-sum)");
		TS_ASSERT_EQUALS(hsum->get_type(), NUMBER_NODE);
		NumberNodePtr sum = NumberNodeCast(hsum);
		TS_ASSERT_LESS_THAN(fabs(sum->get_value() - acc), MAXERR);

		ValuePtr vp = _eval->eval_v("(cog-execute! (DefinedPredicate \"inc\"))");
		BoolValuePtr bvp = BoolValueCast(vp);
		printf("BoolValue for True=%s\n", bvp->to_string().c_str());
		TS_ASSERT_EQUALS(bvp->get_type(), BOOL_VALUE);
		TS_ASSERT(bvp->get_bit(0));
	}

	logger().info("END TEST: %s", __FUNCTION__);
}