Min max size functions added #792

DaddyWesker · 2024-11-07T08:03:43Z

So, I've added three functions: size-atom, max-atom and min-atom. Works as supposed by the name:

!(size-atom (5 4 3))
[3]
!(max-atom (4 3 4.4))
[4.4]
!(min-atom (3 5 2.9))
[2.9]

Documentation and tests are also added.

vsbogd · 2024-11-08T06:44:18Z

lib/src/metta/runner/stdlib.metta

+(@doc min-atom
+  (@desc "Returns atom with min value in the expression (first argument). Only numbers allowed")
+  (@params (
+    (@param "Expression")))


Suggested change

(@param "Expression")))

(@param "Expression which contains atoms of Number type")))

vsbogd · 2024-11-08T06:44:25Z

lib/src/metta/runner/stdlib.metta

+(@doc max-atom
+  (@desc "Returns atom with max value in the expression (first argument). Only numbers allowed")
+  (@params (
+    (@param "Expression")))


Suggested change

(@param "Expression")))

(@param "Expression which contains atoms of Number type")))

vsbogd · 2024-11-08T06:44:57Z

lib/src/metta/runner/stdlib_minimal.metta

+(@doc min-atom
+  (@desc "Returns atom with min value in the expression (first argument). Only numbers allowed")
+  (@params (
+    (@param "Expression")))


Suggested change

(@param "Expression")))

(@param "Expression which contains atoms of Number type")))

vsbogd · 2024-11-08T06:45:03Z

lib/src/metta/runner/stdlib_minimal.metta

+(@doc max-atom
+  (@desc "Returns atom with max value in the expression (first argument). Only numbers allowed")
+  (@params (
+    (@param "Expression")))


Suggested change

(@param "Expression")))

(@param "Expression which contains atoms of Number type")))

vsbogd · 2024-11-08T07:03:28Z

lib/src/metta/runner/stdlib.rs

+        for x in children.iter() {
+            match AsPrimitive::from_atom(x).as_number() {
+                None => Err(ExecError::from("Only numbers allowed in expression")),
+                _ => Ok({}),
+            }?
+        };
+        match children.into_iter().map(|x| Into::<f64>::into(AsPrimitive::from_atom(x).as_number().unwrap())).reduce(f64::min) {
+            Some(min) => Ok(vec![Atom::gnd(Number::Float(min))]),
+            None      => Err(ExecError::from("Empty expression")),
+        }


One doesn't need to iterate through children twice, fold allows doing this in one step

Into::<> is needed only when compiler cannot inference the proper type from context, here it is not needed
I would suggest replacing code by the following:

Suggested change

for x in children.iter() {

match AsPrimitive::from_atom(x).as_number() {

None => Err(ExecError::from("Only numbers allowed in expression")),

_ => Ok({}),

}?

};

match children.into_iter().map(|x| Into::<f64>::into(AsPrimitive::from_atom(x).as_number().unwrap())).reduce(f64::min) {

Some(min) => Ok(vec![Atom::gnd(Number::Float(min))]),

None => Err(ExecError::from("Empty expression")),

}

if children.is_empty() {

Err(ExecError::from("Empty expression"))

} else {

children.into_iter().fold(Ok(f64::INFINITY), |res, x| {

match (res, AsPrimitive::from_atom(x).as_number()) {

(res @ Err(_), _) => res,

(_, None) => Err(ExecError::from("Only numbers are allowed in expression")),

(Ok(min), Some(x)) => Ok(f64::min(min, x.into())),

}

})

}.map(|min| vec![Atom::gnd(Number::Float(min))])

vsbogd · 2024-11-08T07:08:50Z

lib/src/metta/runner/stdlib.rs

+
+impl Grounded for MaxAtomOp {
+    fn type_(&self) -> Atom {
+        Atom::expr([ARROW_SYMBOL, ATOM_TYPE_EXPRESSION, ATOM_TYPE_ATOM])


Suggested change

Atom::expr([ARROW_SYMBOL, ATOM_TYPE_EXPRESSION, ATOM_TYPE_ATOM])

Atom::expr([ARROW_SYMBOL, ATOM_TYPE_EXPRESSION, ATOM_TYPE_NUMBER])

vsbogd · 2024-11-08T07:09:29Z

lib/src/metta/runner/stdlib.rs

+        let res = MinAtomOp{}.execute(&mut vec![expr!({Number::Integer(5)} {Number::Integer(4)} {Number::Float(5.5)})]).expect("No result returned");
+        assert_eq!(res, vec![expr!({Number::Integer(4)})]);
+        let res = MinAtomOp{}.execute(&mut vec![expr!({Number::Integer(5)} {Number::Integer(4)} "A")]);
+        assert_eq!(res, Err(ExecError::from("Only numbers allowed in expression")));


Suggested change

assert_eq!(res, Err(ExecError::from("Only numbers allowed in expression")));

assert_eq!(res, Err(ExecError::from("Only numbers are allowed in expression")));

vsbogd · 2024-11-08T07:09:42Z

lib/src/metta/runner/stdlib.rs

+        let res = MaxAtomOp{}.execute(&mut vec![expr!({Number::Integer(5)} {Number::Integer(4)} {Number::Float(5.5)})]).expect("No result returned");
+        assert_eq!(res, vec![expr!({Number::Float(5.5)})]);
+        let res = MaxAtomOp{}.execute(&mut vec![expr!({Number::Integer(5)} {Number::Integer(4)} "A")]);
+        assert_eq!(res, Err(ExecError::from("Only numbers allowed in expression")));


Suggested change

assert_eq!(res, Err(ExecError::from("Only numbers allowed in expression")));

assert_eq!(res, Err(ExecError::from("Only numbers are allowed in expression")));

vsbogd · 2024-11-08T07:09:59Z

lib/src/metta/runner/stdlib_minimal.rs

+    fn metta_max_atom() {
+        assert_eq!(run_program(&format!("!(max-atom (5 4 5.5))")), Ok(vec![vec![expr!({Number::Float(5.5)})]]));
+        assert_eq!(run_program(&format!("!(max-atom ())")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ()) "Empty expression")]]));
+        assert_eq!(run_program(&format!("!(max-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));


Suggested change

assert_eq!(run_program(&format!("!(max-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));

assert_eq!(run_program(&format!("!(max-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers are allowed in expression")]]));

vsbogd · 2024-11-08T07:10:05Z

lib/src/metta/runner/stdlib_minimal.rs

+    fn metta_min_atom() {
+        assert_eq!(run_program(&format!("!(min-atom (5 4 5.5))")), Ok(vec![vec![expr!({Number::Integer(4)})]]));
+        assert_eq!(run_program(&format!("!(min-atom ())")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ()) "Empty expression")]]));
+        assert_eq!(run_program(&format!("!(min-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));


Suggested change

assert_eq!(run_program(&format!("!(min-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));

assert_eq!(run_program(&format!("!(min-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers are allowed in expression")]]));

vsbogd · 2024-11-08T07:12:57Z

Overall looks good to me, added some suggestions for documentation and code change to eliminate double iteration through expression.

…ental into min_max_size

DaddyWesker · 2024-11-08T07:32:09Z

Overall looks good to me, added some suggestions for documentation and code change to eliminate double iteration through expression.

Thanks for the code changes, now it looks much better. I've pushed those changes.

Innokenty added 3 commits November 5, 2024 07:48

size-atom added

dd00140

documentation for size atom added

812154e

min/max -atom functions added

9eb027b

DaddyWesker requested a review from vsbogd November 7, 2024 08:03

Merge branch 'trueagi-io:main' into min_max_size

7ca3db4

vsbogd reviewed Nov 8, 2024

View reviewed changes

Innokenty added 2 commits November 8, 2024 10:29

Vitaly's fixes

bbc8cca

Merge branch 'min_max_size' of github.com:DaddyWesker/hyperon-experim…

726194a

…ental into min_max_size

Merge branch 'main' into min_max_size

bfb15e0

vsbogd approved these changes Nov 8, 2024

View reviewed changes

vsbogd merged commit 2112a78 into trueagi-io:main Nov 8, 2024
2 checks passed

DaddyWesker deleted the min_max_size branch November 11, 2024 05:26

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Min max size functions added #792

Min max size functions added #792

DaddyWesker commented Nov 7, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd Nov 8, 2024

vsbogd commented Nov 8, 2024

DaddyWesker commented Nov 8, 2024

	(@param "Expression")))
	(@param "Expression which contains atoms of Number type")))

	Atom::expr([ARROW_SYMBOL, ATOM_TYPE_EXPRESSION, ATOM_TYPE_ATOM])
	Atom::expr([ARROW_SYMBOL, ATOM_TYPE_EXPRESSION, ATOM_TYPE_NUMBER])

	assert_eq!(res, Err(ExecError::from("Only numbers allowed in expression")));
	assert_eq!(res, Err(ExecError::from("Only numbers are allowed in expression")));

	assert_eq!(run_program(&format!("!(max-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));
	assert_eq!(run_program(&format!("!(max-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MaxAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers are allowed in expression")]]));

	assert_eq!(run_program(&format!("!(min-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers allowed in expression")]]));
	assert_eq!(run_program(&format!("!(min-atom (3 A B 5))")), Ok(vec![vec![expr!("Error" ({ stdlib::MinAtomOp{} } ({Number::Integer(3)} "A" "B" {Number::Integer(5)})) "Only numbers are allowed in expression")]]));

Min max size functions added #792

Min max size functions added #792

Conversation

DaddyWesker commented Nov 7, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

vsbogd commented Nov 8, 2024

DaddyWesker commented Nov 8, 2024