firefly-compiler 0.4.69 → 0.4.70

package/core/Float.ff

@@ -27,134 +27,142 @@ extend self: Float {
         target js sync "return self_.toFixed(digits_)"
 
     min(that: Float): Float 
-        target js sync "return Math.min(self, that)"
+        target js sync "return Math.min(self_, that_)"
 
     max(that: Float): Float
-        target js sync "return Math.max(self, that)"
+        target js sync "return Math.max(self_, that_)"
 
-    clamp(from: Float, to: Float): Float {
-        if(self <= from) {from} elseIf {self >= to} {to} else {self}
+    clamp(from: Float, to: Float): Float
+        target js sync "return Math.min(Math.max(self_, from_), to_)"
+    
+    lerp(that: Float, factor: Float): Float {
+        self + factor * (that - self)
+    }
+    
+    smoothstep(that: Float, factor: Float): Float {
+        let t = ((factor - self) / (that - self)).clamp(0.0, 1.0)
+        t * t * (3.0 - 2.0 * t)
     }
     
-    expDecay(that: Float, decay: Float, delta: Duration): Float {
-        that + (self - that) * (-decay * delta.seconds).exp()
+    expDecay(that: Float, decay: Float, factor: Float): Float {
+        that + (self - that) * (-decay * factor).exp()
     }
     
     acos(): Float
         target js sync """
-            return Math.acos(self);
+            return Math.acos(self_);
         """
         
     acosh(): Float
         target js sync """
-            return Math.acosh(self);
+            return Math.acosh(self_);
         """
         
     asin(): Float
         target js sync """
-            return Math.asin(self);
+            return Math.asin(self_);
         """
         
     asinh(): Float
         target js sync """
-            return Math.asinh(self);
+            return Math.asinh(self_);
         """
         
     atan(): Float
         target js sync """
-            return Math.atan(self);
+            return Math.atan(self_);
         """
         
     atan2(that: Float): Float
         target js sync """
-            return Math.atan2(self, that);
+            return Math.atan2(self_, that_);
         """
         
     atanh(): Float
         target js sync """
-            return Math.atanh(self);
+            return Math.atanh(self_);
         """
         
     cbrt(): Float
         target js sync """
-            return Math.cbrt(self);
+            return Math.cbrt(self_);
         """
         
     cos(): Float
         target js sync """
-            return Math.cos(self);
+            return Math.cos(self_);
         """
         
     cosh(): Float
         target js sync """
-            return Math.cosh(self);
+            return Math.cosh(self_);
         """
         
     exp(): Float
         target js sync """
-            return Math.exp(self);
+            return Math.exp(self_);
         """
         
     expm1(): Float
         target js sync """
-            return Math.expm1(self);
+            return Math.expm1(self_);
         """
         
     log(that: Float): Float
         target js sync """
-            return Math.log2(self) / Math.log2(that);
+            return Math.log2(self_) / Math.log2(that_);
         """
         
     log10(): Float
         target js sync """
-            return Math.log10(self);
+            return Math.log10(self_);
         """
         
     log2(): Float
         target js sync """
-            return Math.log2(self);
+            return Math.log2(self_);
         """
         
     ln(): Float
         target js sync """
-            return Math.log(self);
+            return Math.log(self_);
         """
         
     ln1p(): Float
         target js sync """
-            return Math.log1p(self);
+            return Math.log1p(self_);
         """
         
     sin(): Float
         target js sync """
-            return Math.sin(self);
+            return Math.sin(self_);
         """
         
     sinh(): Float
         target js sync """
-            return Math.sinh(self);
+            return Math.sinh(self_);
         """
         
     sqrt(): Float
         target js sync """
-            return Math.sqrt(self);
+            return Math.sqrt(self_);
         """
         
     tan(): Float
         target js sync """
-            return Math.tan(self);
+            return Math.tan(self_);
         """
         
     tanh(): Float
         target js sync """
-            return Math.tanh(self);
+            return Math.tanh(self_);
         """
         
 }
 
 hypot(values: List[Float]): Float
     target js sync """
-        return Math.hypot(...values);
+        return Math.hypot(...values_);
     """
 
 e(): Float

package/core/Int.ff

@@ -26,6 +26,9 @@ extend self: Int {
     bitRight(bits: Int, signed: Bool = True): Int
         target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
 
+    bitLeadingZeros(): Int
+        target js sync "return Math.clz32(self_);"
+
     to(inclusiveEnd: Int): List[Int] {
         let result = Array.new()
         mutable n = self
@@ -46,17 +49,14 @@ extend self: Int {
         result.drain()
     }
 
-    min(that: Int): Int {
-        if(self < that) {self} else {that}
-    }
+    min(that: Int): Int 
+        target js sync "return Math.min(self_, that_)"
 
-    max(that: Int): Int {
-        if(self > that) {self} else {that}
-    }
+    max(that: Int): Int
+        target js sync "return Math.max(self_, that_)"
 
-    clamp(from: Int, to: Int): Int {
-        if(self <= from) {from} elseIf {self >= to} {to} else {self}
-    }
+    clamp(from: Int, to: Int): Int
+        target js sync "return Math.min(Math.max(self_, from_), to_)"
     
     pad(padding: String): String {
         ("" + self).padStart(padding.size(), padding)

package/output/js/ff/core/Float.mjs

@@ -97,7 +97,7 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 export function hypot_(values_) {
 
-        return Math.hypot(...values);
+        return Math.hypot(...values_);
     
 }
 
@@ -218,156 +218,159 @@ return self_.toFixed(digits_)
 }
 
 export function Float_min(self_, that_) {
-return Math.min(self, that)
+return Math.min(self_, that_)
 }
 
 export function Float_max(self_, that_) {
-return Math.max(self, that)
+return Math.max(self_, that_)
 }
 
 export function Float_clamp(self_, from_, to_) {
-if((self_ <= from_)) {
-return from_
-} else if((self_ >= to_)) {
-return to_
-} else {
-return self_
+return Math.min(Math.max(self_, from_), to_)
 }
+
+export function Float_lerp(self_, that_, factor_) {
+return (self_ + (factor_ * (that_ - self_)))
+}
+
+export function Float_smoothstep(self_, that_, factor_) {
+const t_ = ff_core_Float.Float_clamp(((factor_ - self_) / (that_ - self_)), 0.0, 1.0);
+return ((t_ * t_) * (3.0 - (2.0 * t_)))
 }
 
-export function Float_expDecay(self_, that_, decay_, delta_) {
-return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * delta_))))
+export function Float_expDecay(self_, that_, decay_, factor_) {
+return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * factor_))))
 }
 
 export function Float_acos(self_) {
 
-            return Math.acos(self);
+            return Math.acos(self_);
         
 }
 
 export function Float_acosh(self_) {
 
-            return Math.acosh(self);
+            return Math.acosh(self_);
         
 }
 
 export function Float_asin(self_) {
 
-            return Math.asin(self);
+            return Math.asin(self_);
         
 }
 
 export function Float_asinh(self_) {
 
-            return Math.asinh(self);
+            return Math.asinh(self_);
         
 }
 
 export function Float_atan(self_) {
 
-            return Math.atan(self);
+            return Math.atan(self_);
         
 }
 
 export function Float_atan2(self_, that_) {
 
-            return Math.atan2(self, that);
+            return Math.atan2(self_, that_);
         
 }
 
 export function Float_atanh(self_) {
 
-            return Math.atanh(self);
+            return Math.atanh(self_);
         
 }
 
 export function Float_cbrt(self_) {
 
-            return Math.cbrt(self);
+            return Math.cbrt(self_);
         
 }
 
 export function Float_cos(self_) {
 
-            return Math.cos(self);
+            return Math.cos(self_);
         
 }
 
 export function Float_cosh(self_) {
 
-            return Math.cosh(self);
+            return Math.cosh(self_);
         
 }
 
 export function Float_exp(self_) {
 
-            return Math.exp(self);
+            return Math.exp(self_);
         
 }
 
 export function Float_expm1(self_) {
 
-            return Math.expm1(self);
+            return Math.expm1(self_);
         
 }
 
 export function Float_log(self_, that_) {
 
-            return Math.log2(self) / Math.log2(that);
+            return Math.log2(self_) / Math.log2(that_);
         
 }
 
 export function Float_log10(self_) {
 
-            return Math.log10(self);
+            return Math.log10(self_);
         
 }
 
 export function Float_log2(self_) {
 
-            return Math.log2(self);
+            return Math.log2(self_);
         
 }
 
 export function Float_ln(self_) {
 
-            return Math.log(self);
+            return Math.log(self_);
         
 }
 
 export function Float_ln1p(self_) {
 
-            return Math.log1p(self);
+            return Math.log1p(self_);
         
 }
 
 export function Float_sin(self_) {
 
-            return Math.sin(self);
+            return Math.sin(self_);
         
 }
 
 export function Float_sinh(self_) {
 
-            return Math.sinh(self);
+            return Math.sinh(self_);
         
 }
 
 export function Float_sqrt(self_) {
 
-            return Math.sqrt(self);
+            return Math.sqrt(self_);
         
 }
 
 export function Float_tan(self_) {
 
-            return Math.tan(self);
+            return Math.tan(self_);
         
 }
 
 export function Float_tanh(self_) {
 
-            return Math.tanh(self);
+            return Math.tanh(self_);
         
 }
 
@@ -412,17 +415,20 @@ throw new Error('Function Float_max is missing on this target in async context.'
 }
 
 export async function Float_clamp$(self_, from_, to_, $task) {
-if((self_ <= from_)) {
-return from_
-} else if((self_ >= to_)) {
-return to_
-} else {
-return self_
+throw new Error('Function Float_clamp is missing on this target in async context.');
 }
+
+export async function Float_lerp$(self_, that_, factor_, $task) {
+return (self_ + (factor_ * (that_ - self_)))
+}
+
+export async function Float_smoothstep$(self_, that_, factor_, $task) {
+const t_ = ff_core_Float.Float_clamp(((factor_ - self_) / (that_ - self_)), 0.0, 1.0);
+return ((t_ * t_) * (3.0 - (2.0 * t_)))
 }
 
-export async function Float_expDecay$(self_, that_, decay_, delta_, $task) {
-return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * delta_))))
+export async function Float_expDecay$(self_, that_, decay_, factor_, $task) {
+return (that_ + ((self_ - that_) * ff_core_Float.Float_exp(((-decay_) * factor_))))
 }
 
 export async function Float_acos$(self_, $task) {

package/output/js/ff/core/Int.mjs

@@ -131,6 +131,10 @@ export function Int_bitRight(self_, bits_, signed_ = true) {
 return signed_ ? self_ >> bits_ : self_ >>> bits_;
 }
 
+export function Int_bitLeadingZeros(self_) {
+return Math.clz32(self_);
+}
+
 export function Int_to(self_, inclusiveEnd_) {
 const result_ = ff_core_Array.new_();
 let n_ = self_;
@@ -152,29 +156,15 @@ return ff_core_Array.Array_drain(result_)
 }
 
 export function Int_min(self_, that_) {
-if((self_ < that_)) {
-return self_
-} else {
-return that_
-}
+return Math.min(self_, that_)
 }
 
 export function Int_max(self_, that_) {
-if((self_ > that_)) {
-return self_
-} else {
-return that_
-}
+return Math.max(self_, that_)
 }
 
 export function Int_clamp(self_, from_, to_) {
-if((self_ <= from_)) {
-return from_
-} else if((self_ >= to_)) {
-return to_
-} else {
-return self_
-}
+return Math.min(Math.max(self_, from_), to_)
 }
 
 export function Int_pad(self_, padding_) {
@@ -221,6 +211,10 @@ export async function Int_bitRight$(self_, bits_, signed_ = true, $task) {
 throw new Error('Function Int_bitRight is missing on this target in async context.');
 }
 
+export async function Int_bitLeadingZeros$(self_, $task) {
+throw new Error('Function Int_bitLeadingZeros is missing on this target in async context.');
+}
+
 export async function Int_to$(self_, inclusiveEnd_, $task) {
 const result_ = ff_core_Array.new_();
 let n_ = self_;
@@ -242,29 +236,15 @@ return ff_core_Array.Array_drain(result_)
 }
 
 export async function Int_min$(self_, that_, $task) {
-if((self_ < that_)) {
-return self_
-} else {
-return that_
-}
+throw new Error('Function Int_min is missing on this target in async context.');
 }
 
 export async function Int_max$(self_, that_, $task) {
-if((self_ > that_)) {
-return self_
-} else {
-return that_
-}
+throw new Error('Function Int_max is missing on this target in async context.');
 }
 
 export async function Int_clamp$(self_, from_, to_, $task) {
-if((self_ <= from_)) {
-return from_
-} else if((self_ >= to_)) {
-return to_
-} else {
-return self_
-}
+throw new Error('Function Int_clamp is missing on this target in async context.');
 }
 
 export async function Int_pad$(self_, padding_, $task) {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.69",
+    "version": "0.4.70",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.69",
+    "version": "0.4.70",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"