Conversions Tool

xholonWorkbook.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--Xholon Workbook http://www.primordion.com/Xholon/gwt/ MIT License, Copyright (C) Ken Webb, Fri Aug 29 2025 17:05:10 GMT-0400 (Eastern Daylight Time)-->
<XholonWorkbook>

<Notes><![CDATA[
Xholon
------
Title: Conversions Tool
Description: 
Url: http://www.primordion.com/Xholon/gwt/
InternalName: cf6decf56a1fd143d4e884fcfe642f65
Keywords: 

My Notes
--------
2025 August 1

This workbook will collect functions that perform a wide range of conversations, for example between celcius and fahrenheit.

After writing a few of my own functions, I tried using my local ollama. After a few attempts, it did very well.

## To use in Dev Tools (Firefox, Chrome, etc.)
xh.Conversions.Mass.kg2lb(20) displays 44.0924

## TODO
- add an HTML GUI, possibly to the xhappspecific div
    const igsContainer = $doc.getElementById('xhappspecific');
    igsContainer.textContent = responseText;
    
    - see https://gist.github.com/kenwebb/95271aafa6f83df57059
       D3 animations, transitions, tweens, etc.
       2014
     - use of d3 to add content to xhappspecific
     http://192.168.2.10:8080/Xholon.html?app=95271aafa6f83df57059&src=gist&gui=clsc
      - a good example

- The GUI should be laid out with:
  - a high level menu (Length, Temperature, etc.)
  - a detailed function menu (mm2cm etc. for Length, etc.)
    each high level menu has its own detailed function sub-menu
  - a user input field
  - a result field
- example:
  Length.mm2cm( 100 ) = ??
  Temp  .c2f  ( 37  ) = ??
  
## Lambda  2025 Aug 29
- I added lambda λ notation for some of the functions
- see on rip: ~/gwtspace/AiStuff_2025/LambdaGpt5mini/index.html
- $ npx http-server
- see: https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1

## References

(1) https://en.wikipedia.org/wiki/Conversion_of_scales_of_temperature
    has tables, calculator, formulas, etc.

(2) https://en.wikipedia.org/wiki/Temperature

(3) https://en.wikipedia.org/wiki/Dimensional_analysis#Formulation

    There are many possible choices of base physical dimensions. The SI standard selects the following dimensions and corresponding dimension symbols:

    time (T), length (L), mass (M), electric current (I), absolute temperature (Θ), amount of substance (N) and luminous intensity (J).

    The symbols are by convention usually written in roman sans serif typeface.[2] Mathematically, the dimension of the quantity Q is given by

    dim ⁡ Q = T a L b M c I d Θ e N f J g {\displaystyle \operatorname {dim} Q={\mathsf {T}}^{a}{\mathsf {L}}^{b}{\mathsf {M}}^{c}{\mathsf {I}}^{d}{\mathsf {\Theta }}^{e}{\mathsf {N}}^{f}{\mathsf {J}}^{g}}

(4) https://www.omniunitconverter.com/
    - mentioned in wikipedia

]]></Notes>

<markdown><![CDATA[
% ollama run llama3
>>> Write a set of javascript arrow functions that convert between celcius, fahrenheit, and kelvin. Each function should be one line. Place the functions inside an Object called Temperature.

Here is the JavaScript code:

```
const Temperature = {
  fromCelsius: (c) => c * 9/5 + 32,
  fromFahrenheit: (f) => (f - 32) * 5/9,
  fromKelvin: (k) => k * 9/5 - 459.67
};

console.log(Temperature.fromCelsius(100)); // outputs 212
console.log(Temperature.fromFahrenheit(212)); // outputs 100
console.log(Temperature.fromKelvin(373.15)); // outputs 100
```

These arrow functions can be used to convert between Celsius, Fahrenheit, and Kelvin temperatures. For example, `Temperature.fromCelsius(100)` will return the Fahrenheit 
equivalent of 100°C, which is 212°F.

>>> Rename the functions so that the name identifies the from and to measurements. For example, "cels2fahr" instead of "fromCelsius".

Here's the updated code:

```
const Temperature = {
  cels2fahr: (c) => c * 9/5 + 32,
  fahr2cels: (f) => (f - 32) * 5/9,
  kelv2cels: (k) => k * 1 - 273.15,
  kelv2fahr: (k) => k * 9/5 - 459.67
};

console.log(Temperature.cels2fahr(100)); // outputs 212
console.log(Temperature.fahr2cels(212)); // outputs 100
console.log(Temperature.kelv2cels(373.15)); // outputs 99.9
console.log(Temperature.kelv2fahr(373.15)); // outputs 212
```

Now the function names clearly indicate which measurements they convert from and to, making it easier to understand their purpose.

>>> Also include cels2kelv and fahr2kelv.

Here's the updated code:

```
const Temperature = {
  cels2fahr: (c) => c * 9/5 + 32,
  fahr2cels: (f) => (f - 32) * 5/9,
  kelv2cels: (k) => k * 1 - 273.15,
  kelv2fahr: (k) => k * 9/5 - 459.67,
  cels2kelv: (c) => c + 273.15,
  fahr2kelv: (f) => (f + 459.67) / 1.8
};

console.log(Temperature.cels2fahr(100)); // outputs 212
console.log(Temperature.fahr2cels(212)); // outputs 100
console.log(Temperature.kelv2cels(373.15)); // outputs 99.9
console.log(Temperature.kelv2fahr(373.15)); // outputs 212
console.log(Temperature.cels2kelv(100)); // outputs 373.15
console.log(Temperature.fahr2kelv(212)); // outputs 373.15
```

Now the `Temperature` object includes functions to convert between all three units: Celsius, Fahrenheit, and Kelvin.


>>> Create an analogous object called Length. Provide a complete set of arrow functions that convert between each pair in the set: mm cm m km inch foot yard mile.

Here's the `Length` object with the necessary conversion functions:

```
const Length = {
  mm2cm: (mm) => mm / 10,
  cm2mm: (cm) => cm * 10,
  mm2m: (mm) => mm / 1000,
  m2mm: (m) => m * 1000,
  mm2km: (mm) => mm / 1e6,
  km2mm: (km) => km * 1e6,
  cm2m: (cm) => cm / 100,
  m2cm: (m) => m * 100,
  cm2km: (cm) => cm / 100000,
  km2cm: (km) => km * 100000,
  inch2mm: (inch) => inch * 25.4,
  mm2inch: (mm) => mm / 25.4,
  ft2in: (ft) => ft * 12,
  in2ft: (inch) => inch / 12,
  yd2ft: (yd) => yd * 3,
  ft2yd: (ft) => ft / 3,
  mile2km: (mile) => mile * 1.60934,
  km2mile: (km) => km / 1.60934
};

console.log(Length.mm2cm(100)); // outputs 10
console.log(Length.cm2mm(50)); // outputs 500
console.log(Length.mm2m(1000)); // outputs 1
console.log(Length.m2mm(1)); // outputs 1000
console.log(Length.mm2km(1000000)); // outputs 1
console.log(Length.km2mm(1)); // outputs 1000000
console.log(Length.cm2m(10)); // outputs 0.1
console.log(Length.m2cm(1)); // outputs 100
console.log(Length.cm2km(50000)); // outputs 0.5
console.log(Length.km2cm(2000)); // outputs 2000000
console.log(Length.inch2mm(4)); // outputs 101.6
console.log(Length.mm2inch(101.6)); // outputs 4
console.log(Length.ft2in(6)); // outputs 72
console.log(Length.in2ft(36)); // outputs 3
console.log(Length.yd2ft(10)); // outputs 30
console.log(Length.ft2yd(30)); // outputs 1
console.log(Length.mile2km(5)); // outputs 8.04672
console.log(Length.km2mile(8)); // outputs 4.97114

>>> Thank you for the help with Temperature and Length. What other dimensions can you help with?

I'm glad I could help!

I can assist with other dimensions as well, such as:

1. Time: Converting between different time units like seconds, minutes, hours, days, weeks, months, years.
2. Mass: Converting between different mass units like grams, kilograms, tons, pounds, ounces.
3. Speed: Converting between different speed units like meters per second, kilometers per hour, miles per hour, feet per second.
4. Angle: Converting between different angle units like degrees, radians, minutes, seconds.

Let me know if you'd like help with any of these or other dimensions!

>>> Please do the Time conversions for me.

Here's a `Time` object with conversion functions:

```
const Time = {
  sec2min: (sec) => sec / 60,
  min2sec: (min) => min * 60,
  sec2hour: (sec) => sec / 3600,
  hour2sec: (hour) => hour * 3600,
  sec2day: (sec) => sec / 86400,
  day2sec: (day) => day * 86400,
  min2hour: (min) => min / 60,
  hour2min: (hour) => hour * 60,
  day2hour: (day) => day * 24
};

console.log(Time.sec2min(60)); // outputs 1
console.log(Time.min2sec(30)); // outputs 1800
console.log(Time.sec2hour(3600)); // outputs 1
console.log(Time.hour2sec(1)); // outputs 3600
console.log(Time.sec2day(86400)); // outputs 1
console.log(Time.day2sec(1)); // outputs 86400
console.log(Time.min2hour(1)); // outputs 0.01666666666666667
console.log(Time.hour2min(1)); // outputs 60
console.log(Time.day2hour(1)); // outputs 24
```

Now you can easily convert between different time units!


% ollama run llama3
>>> Write a set of javascript arrow functions that convert between units of mass such as grams, kilograms, tons, pounds, ounces.
Each function should be one line.
Place the functions inside an Object called Mass.
Name the functions so that the name identifies the from and to measurements. For example, "g2kg".

Here is a set of JavaScript arrow functions that convert between units of mass:

```
const Mass = {
  g2mg: (grams) => grams * 1000,
  kg2t: (kilograms) => kilograms / 1000,
  t2kg: (tons) => tons * 1000,
  lb2oz: (pounds) => pounds * 16,
  oz2lb: (ounces) => ounces / 16,
  g2lb: (grams) => grams / 453.59237,
  kg2lb: (kilograms) => kilograms * 2.20462,
  t2lb: (tons) => tons * 2000,
  lb2t: (pounds) => pounds / 2000
};
```

These functions can be used to convert between different units of mass, for example:

* Convert grams to milligrams: `Mass.g2mg(100)`
* Convert tons to kilograms: `Mass.t2kg(1.5)`
* Convert ounces to pounds: `Mass.oz2lb(16)`

>>> Do the same thing for speed.

Here is a set of JavaScript arrow functions that convert between units of speed:

```
const Speed = {
  kmh2mph: (kilometersPerHour) => kilometersPerHour * 0.621371,
  mph2kph: (milesPerHour) => milesPerHour / 0.621371,
  mps2kmh: (metersPerSecond) => metersPerSecond * 3.6,
  kmh2mps: (kilometersPerHour) => kilometersPerHour / 3.6,
  mph2fps: (milesPerHour) => milesPerHour * 1.46726,
  fps2mph: (feetPerSecond) => feetPerSecond / 1.46726
};
```

These functions can be used to convert between different units of speed, for example:

* Convert kilometers per hour to miles per hour: `Speed.kmh2mph(100)`
* Convert meters per second to kilometers per hour: `Speed.mps2kmh(25)`
* Convert feet per second to miles per hour: `Speed.fps2mph(20)`

>>> Do the same for Angle.

Here is a set of JavaScript arrow functions that convert between units of angle:

```
const Angle = {
  deg2rad: (degrees) => degrees * Math.PI / 180,
  rad2deg: (radians) => radians * 180 / Math.PI,
  grad2deg: (gradients) => gradients * 0.9,
  deg2grad: (degrees) => degrees * 1.143
};
```

These functions can be used to convert between different units of angle, for example:

* Convert degrees to radians: `Angle.deg2rad(45)`
* Convert radians to degrees: `Angle.rad2deg(Math.PI / 2)`
* Convert gradients to degrees: `Angle.grad2deg(135)`

## TODO electricity

>>> Can you do the same for electricity?

Here is a set of JavaScript arrow functions that convert between units of electricity:

```
const Electricity = {
  kVAtoW: (kiloVoltsAmps) => kiloVoltsAmps * 1000,
  WA2kVArms: (wattsAmperes) => wattsAmperes / 1000,
  A2mA: (amperes) => amperes * 1000,
  mAA2A: (milliAmperes) => milliAmperes / 1000,
  V2mV: (volts) => volts * 1000,
  mVV2V: (milliVolts) => milliVolts / 1000
};
```

These functions can be used to convert between different units of electricity, for example:

* Convert kiloVoltsAmps to watts: `Electricity.kVAtoW(10)`
* Convert wattsAmperes to kiloVoltsAmps: `Electricity.WA2kVArms(5000)`
* Convert milliAmperes to amperes: `Electricity.A2mA(250)`
* Convert millivolts to volts: `Electricity.V2mV(250)`

>>> Please describe these functions in more detail.

Here's a breakdown of each function in the `Electricity` object:

1. `kVAtoW(kiloVoltsAmps)`: This function converts kiloVolts-Amps (kVA) to Watts (W). kVA is a unit of apparent power, which includes both real and reactive power. Watts, on 
the other hand, are a measure of real power. The conversion factor is 1000, since there are 1000 watts in one kilowatt.

Example: `Electricity.kVAtoW(10)` would convert 10 kVA to Watts, returning approximately 10000 W.

2. `WA2kVArms(wattsAmperes)`: This function converts Watts-Amperes (WA) to kiloVolts-Amps (kVA). WA is a measure of real power and current, while kVA includes both real and 
reactive power. The conversion factor is 1/1000, since there are 1000 WA in one kVA.

Example: `Electricity.WA2kVArms(5000)` would convert 5000 WA to kVA, returning approximately 5 kVA.

3. `A2mA(amperes)`: This function converts Amperes (A) to milliAmperes (mA). There are 1000 mA in one A, so the conversion factor is simply 1000.

Example: `Electricity.A2mA(250)` would convert 250 A to mA, returning approximately 250000 mA.

4. `mAA2A(milliAmperes)`: This function converts milliAmperes (mA) to Amperes (A). As above, there are 1000 A in one mA, so the conversion factor is also 1/1000.

Example: `Electricity.mAA2A(250000)` would convert 250000 mA to A, returning approximately 250 A.

5. `V2mV(volts)`: This function converts Volts (V) to milliVolts (mV). There are 1000 mV in one V, so the conversion factor is again simply 1000.

Example: `Electricity.V2mV(250)` would convert 250 V to mV, returning approximately 250000 mV.

6. `mVV2V(milliVolts)`: This function converts milliVolts (mV) to Volts (V). As above, there are 1000 V in one mV, so the conversion factor is also 1/1000.

Example: `Electricity.mVV2V(250000)` would convert 250000 mV to V, returning approximately 250 V.

These functions can be used for unit conversions when working with electrical measurements.

>>> Provide arrow functions for Ohms Law.

Here are some JavaScript arrow functions that implement Ohm's Law:

```
const OhmsLaw = {
  V2R(V, I) => V / I,
  RI2V(R, I) => R * I,
  VRI2P(V, R, I) => (V * I) / R
};
```

These functions can be used to calculate voltage (V), resistance (R), and current (I) based on Ohm's Law:

1. `V2R(V, I)`: This function calculates the resistance (R) given the voltage (V) and current (I). The formula is R = V / I.

Example: `OhmsLaw.V2R(10, 0.5)` would calculate the resistance given a voltage of 10 V and a current of 0.5 A, returning approximately 20 ohms.

2. `RI2V(R, I)`: This function calculates the voltage (V) given the resistance (R) and current (I). The formula is V = R * I.

Example: `OhmsLaw.RI2V(10, 0.5)` would calculate the voltage given a resistance of 10 ohms and a current of 0.5 A, returning approximately 5 volts.

3. `VRI2P(V, R, I)`: This function calculates the power (P) given the voltage (V), resistance (R), and current (I). The formula is P = (V * I) / R.

Example: `OhmsLaw.VRI2P(10, 5, 0.5)` would calculate the power given a voltage of 10 V, a resistance of 5 ohms, and a current of 0.5 A, returning approximately 2.5 watts.

% ollama run llama3

>>> Write an HTML menu where the user selects between: Length, Temperature, Mass. Once the user makes their selection, display a sub-menu. For example if Length is chosen, then the 
... sub-menu will contain: mm2cm, cm2inch, km2mile .

Here is an example of an HTML menu that achieves the functionality you described:
```
<!DOCTYPE html>
<html>
<head>
  <title>Unit Converter</title>
</head>
<body>
  <h1>Unit Converter</h1>
  <form>
    <label for="main-menu">Select a unit:</label>
    <select id="main-menu" onchange="showSubMenu()">
      <option value="temperature">Temperature</option>
      <option value="length">Length</option>
      <option value="time">Time</option>
      <option value="mass">Mass</option>
      <option value="speed">Speed</option>
      <option value="angle">Angle</option>
    </select>
  </form>
  
  <div id="sub-menu"></div>

  <script>
    function showSubMenu() {
      var mainMenu = document.getElementById("main-menu");
      var selection = mainMenu.options[mainMenu.selectedIndex].value;
      
      if (selection === "length") {
        var subMenuHtml = "";
        subMenuHtml += "<label for='sub-menu'>Select a conversion:</label>";
        subMenuHtml += "<select id='sub-menu'>";
        subMenuHtml += "<option value='mm2cm'>mm to cm</option>";
        subMenuHtml += "<option value='cm2inch'>cm to inch</option>";
        subMenuHtml += "<option value='km2mile'>km to mile</option>";
        subMenuHtml += "</select>";
        
        document.getElementById("sub-menu").innerHTML = subMenuHtml;
      } else if (selection === "temperature") {
        // add temperature conversion options here
      } else if (selection === "mass") {
        // add mass conversion options here
      }
    }
  </script>
</body>
</html>
```
Here's how it works:

1. The user selects a main unit from the dropdown menu.
2. When the selection changes, the `showSubMenu()` function is called.
3. The function determines which main unit was selected and creates a sub-menu with relevant conversion options.
4. The sub-menu is displayed below the main menu.

Note that this example only includes length conversions for now. You'll need to add more code to handle temperature and mass conversions, as well as populate the sub-menu with 
relevant options.

]]></markdown> 

<_-.XholonClass>
  <ConversionsSystem/>
  
  <Conversions/>
  <ConversionsScript superClass="Script"/>
  
  <!-- TODO separate node for each Dimension, etc. -->
  <Temperature/>
  
  <TemperatureAI superClass="Script"/>
  <LengthAI superClass="Script"/>
  <TimeAI superClass="Script"/>
  <MassAI superClass="Script"/>
  <SpeedAI superClass="Script"/>
  <AngleAI superClass="Script"/>
  
  <Electricity/> <!-- TODO -->
  
  <!-- quantities -->
  <QLength superClass="Quantity"/>
  
  <MenuScript superClass="Script"/>
  <MenuScript0 superClass="Script"/>
  
</_-.XholonClass>

<xholonClassDetails>
  
  <ConversionsScript><DefaultContent><![CDATA[
const celcius = 100;
this.println(celcius);
const ctof = (c) => (c * 1.8) + 32; // celcius to fahrenheit ℉=(℃*1.8)+32
const result = `${celcius}℃ = ${ctof(celcius)}℉`;
this.println(result);

// write some HTML to xhappspecific
//const xhapp = $doc.getElementById('xhappspecific');
//xhapp.textContent = result;

// or
$wnd.d3.select("body > div#xhappspecific").append("div").append("h3").text(result);
  ]]></DefaultContent></ConversionsScript>
  
  <!-- this node is automatically removed unless there is a beh object -->
  <TemperatureAI roleName="Θ"><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}
$wnd.xh.Conversions.Temperature = {    // lambda
  cels2fahr: (c) => c * 9/5 + 32,      // λc.c*9/5+32
  fahr2cels: (f) => (f - 32) * 5/9,    // λf.(f-32)*5/9
  kelv2cels: (k) => k * 1 - 273.15,    // λk.k-273.15
  kelv2fahr: (k) => k * 9/5 - 459.67,  // λk.k*9/5-459.67
  cels2kelv: (c) => c + 273.15,        // λc.c+273.15
  fahr2kelv: (f) => (f + 459.67) / 1.8 // λf.(f+459.67)/1.8
};

// testing  it works!
console.log("\nTemperature");
const Temp = $wnd.xh.Conversions.Temperature;
console.log(Temp.cels2fahr(100));    // outputs 212
console.log(Temp.fahr2cels(212));    // outputs 100
console.log(Temp.kelv2cels(373.15)); // outputs 99.9 100
console.log(Temp.kelv2fahr(373.15)); // outputs 212 211.99999999999994
console.log(Temp.cels2kelv(100));    // outputs 373.15
console.log(Temp.fahr2kelv(212));    // outputs 373.15
$wnd.d3.select("body > div#xhappspecific").append("div").append("h3").text(`212°F = ${Temp.fahr2kelv(212)}°K`);

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name() + me.role()); // role() returns null
  }
}

]]></DefaultContent></TemperatureAI>
  
  <LengthAI><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}
$wnd.xh.Conversions.Length = {     // lambda
  mm2cm: (mm) => mm / 10,          // λm.m/10
  cm2mm: (cm) => cm * 10,
  mm2m:  (mm) => mm / 1000,
  m2mm:  (m) => m * 1000,
  mm2km: (mm) => mm / 1e6,
  km2mm: (km) => km * 1e6,
  cm2m:  (cm) => cm / 100,
  m2cm:  (m) => m * 100,
  cm2km: (cm) => cm / 100000,
  km2cm: (km) => km * 100000,
  inch2mm: (inch) => inch * 25.4,
  mm2inch: (mm) => mm / 25.4,
  ft2in: (ft) => ft * 12,
  in2ft: (inch) => inch / 12,
  yd2ft: (yd) => yd * 3,
  ft2yd: (ft) => ft / 3,
  mile2km: (mile) => mile * 1.60934,
  km2mile: (km) => km / 1.60934
};

// testing  it works!
console.log("\nLength");
const Length = $wnd.xh.Conversions.Length;
console.log(Length.mm2cm(100));     // outputs 10
console.log(Length.cm2mm(50));      // outputs 500
console.log(Length.mm2m(1000));     // outputs 1
console.log(Length.m2mm(1));        // outputs 1000
console.log(Length.mm2km(1000000)); // outputs 1
console.log(Length.km2mm(1));       // outputs 1000000
console.log(Length.cm2m(10));       // outputs 0.1
console.log(Length.m2cm(1));        // outputs 100
console.log(Length.cm2km(50000));   // outputs 0.5
console.log(Length.km2cm(2000));    // outputs 2000000
console.log(Length.inch2mm(4));     // outputs 101.6
console.log(Length.mm2inch(101.6)); // outputs 4
console.log(Length.ft2in(6));       // outputs 72
console.log(Length.in2ft(36));      // outputs 3
console.log(Length.yd2ft(10));      // outputs 30
console.log(Length.ft2yd(30));      // outputs 10
console.log(Length.mile2km(5));     // outputs 8.0467
console.log(Length.km2mile(8));     // outputs 4.970981893198454
$wnd.d3.select("body > div#xhappspecific").append("div").append("h3").text(`100mm = ${Length.mm2cm(100)}cm`);

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name());
  }
}

]]></DefaultContent></LengthAI>
  
  <TimeAI><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}

$wnd.xh.Conversions.Time = {
  sec2min: (sec) => sec / 60,
  min2sec: (min) => min * 60,
  sec2hour: (sec) => sec / 3600,
  hour2sec: (hour) => hour * 3600,
  sec2day: (sec) => sec / 86400,
  day2sec: (day) => day * 86400,
  min2hour: (min) => min / 60,
  hour2min: (hour) => hour * 60,
  day2hour: (day) => day * 24
};

// testing  it works!
console.log("\nTime");
const Time = $wnd.xh.Conversions.Time;
console.log(Time.sec2min(60)); // outputs 1
console.log(Time.min2sec(30)); // outputs 1800
console.log(Time.sec2hour(3600)); // outputs 1
console.log(Time.hour2sec(1)); // outputs 3600
console.log(Time.sec2day(86400)); // outputs 1
console.log(Time.day2sec(1)); // outputs 86400
console.log(Time.min2hour(1)); // outputs 0.01666666666666667
console.log(Time.hour2min(1)); // outputs 60
console.log(Time.day2hour(1)); // outputs 24

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name());
  }
}

]]></DefaultContent></TimeAI>

  <MassAI><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}

$wnd.xh.Conversions.Mass = {
  g2mg: (grams) => grams * 1000,
  kg2t: (kilograms) => kilograms / 1000,
  t2kg: (tons) => tons * 1000,
  lb2oz: (pounds) => pounds * 16,
  oz2lb: (ounces) => ounces / 16,
  g2lb: (grams) => grams / 453.59237,
  kg2lb: (kilograms) => kilograms * 2.20462,
  t2lb: (tons) => tons * 2000,
  lb2t: (pounds) => pounds / 2000
};

//* Convert grams to milligrams: `Mass.g2mg(100)`
//* Convert tons to kilograms: `Mass.t2kg(1.5)`
//* Convert ounces to pounds: `Mass.oz2lb(16)`


// testing  TODO
console.log("\nMass");
const Mass = $wnd.xh.Conversions.Mass;
console.log(Mass.g2mg(100)); // 
console.log(Mass.t2kg(1.5)); // 
console.log(Mass.oz2lb(16)); // 

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name());
  }
}

]]></DefaultContent></MassAI>
  
  <SpeedAI><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}

$wnd.xh.Conversions.Speed = {
  kmh2mph: (kilometersPerHour) => kilometersPerHour * 0.621371,
  mph2kph: (milesPerHour) => milesPerHour / 0.621371,
  mps2kmh: (metersPerSecond) => metersPerSecond * 3.6,
  kmh2mps: (kilometersPerHour) => kilometersPerHour / 3.6,
  mph2fps: (milesPerHour) => milesPerHour * 1.46726,
  fps2mph: (feetPerSecond) => feetPerSecond / 1.46726
};

//* Convert kilometers per hour to miles per hour: `Speed.kmh2mph(100)`
//* Convert meters per second to kilometers per hour: `Speed.mps2kmh(25)`
//* Convert feet per second to miles per hour: `Speed.fps2mph(20)`

// testing  TODO
console.log("\nSpeed");
const Speed = $wnd.xh.Conversions.Speed;
console.log(Speed.kmh2mph(100)); // 
console.log(Speed.mps2kmh(25)); // 
console.log(Speed.fps2mph(20)); // 

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name());
  }
}

]]></DefaultContent></SpeedAI>

  <AngleAI><DefaultContent><![CDATA[
if (!$wnd.xh.Conversions) {
  $wnd.xh.Conversions = {};
}

$wnd.xh.Conversions.Angle = {
  deg2rad: (degrees) => degrees * Math.PI / 180,
  rad2deg: (radians) => radians * 180 / Math.PI,
  grad2deg: (gradients) => gradients * 0.9,
  deg2grad: (degrees) => degrees * 1.143
};

//These functions can be used to convert between different units of angle, for example:

//* Convert degrees to radians: `Angle.deg2rad(45)`
//* Convert radians to degrees: `Angle.rad2deg(Math.PI / 2)`
//* Convert gradients to degrees: `Angle.grad2deg(135)`

// testing  TODO
console.log("\nAngle");
const Angle = $wnd.xh.Conversions.Angle;
console.log(Angle.deg2rad(45)); // 
console.log(Angle.rad2deg(Math.PI / 2)); // 
console.log(Angle.grad2deg(135)); // 

var me, beh = {
  postConfigure: function() {
    me = this.cnode;
    me.println(me.name());
  }
}

]]></DefaultContent></AngleAI>
  
  <MenuScript><DefaultContent><![CDATA[
$wnd.xh.showSubMenu = function() {
  var mainMenuDiv = $doc.querySelector("#main-menu-div");
  var mainMenu = $doc.querySelector("#main-menu");
  var selection = mainMenu.options[mainMenu.selectedIndex].value;
  $wnd.console.log(selection + " was selected ...");
  
  if (selection === "Temperature") {
    // add temperature conversion options here
    //$wnd.console.log("Temperature was selected ...");
  }
  else if (selection === "Length") {
    var subMenuHtml = `<p>${selection}</p>`;
    subMenuHtml += "<label for='sub-menu'>Select a conversion:</label>";
    subMenuHtml += "<select id='sub-menu'>";
    subMenuHtml += "<option value='mm2cm'>mm 2 cm</option>";
    subMenuHtml += "<option value='cm2mm'>cm 2 mm</option>";
    subMenuHtml += "<option value='mm2m'>mm 2 m</option>";
    subMenuHtml += "<option value='m2mm'>m 2 mm</option>";
    subMenuHtml += "<option value='mm2km'>mm 2 km</option>";
    subMenuHtml += "<option value='km2mm'>km 2 mm</option>";
    subMenuHtml += "<option value='cm2m'>cm 2 m</option>";
    subMenuHtml += "<option value='m2cm'>m 2 cm</option>";
    subMenuHtml += "<option value='cm2km'>cm 2 km</option>";
    subMenuHtml += "<option value='km2cm'>km 2 cm</option>";
    subMenuHtml += "<option value='inch2mm'>inch 2 mm</option>";
    subMenuHtml += "<option value='mm2inch'>mm 2 inch</option>";
    subMenuHtml += "<option value='ft2in'>ft 2 in</option>";
    subMenuHtml += "<option value='in2ft'>in 2 ft</option>";
    subMenuHtml += "<option value='yd2ft'>yd 2 ft</option>";
    subMenuHtml += "<option value='ft2yd'>ft 2 yd</option>";
    subMenuHtml += "<option value='mile2km'>mile 2 km</option>";
    subMenuHtml += "<option value='km2mile'>km 2 mile</option>";
    subMenuHtml += "<input type='text' id='inval' name='inval'><br><br><input type='submit' value='Submit'>";
    subMenuHtml += "</select>";
    mainMenuDiv.innerHTML = subMenuHtml;
  }
  else if (selection === "Time") {
    // add time conversion options here
    //$wnd.console.log("Time was selected ...");
  }
  else if (selection === "Mass") {
    // add mass conversion options here
    //$wnd.console.log("Mass was selected ...");
  }
  else if (selection === "Speed") {
    // add speed conversion options here
    //$wnd.console.log("Speed was selected ...");
  }
  else if (selection === "Angle") {
    // add angle conversion options here
    //$wnd.console.log("Angle was selected ...");
  }
}
//# sourceURL=MenuScript.js
]]></DefaultContent></MenuScript>
  
  <MenuScript0><DefaultContent><![CDATA[
const xhapp = $doc.getElementById('xhappspecific');
xhapp.innerHTML = `
<div id="main-menu-div" style="background-color: orange; border: 10px solid #e69500;">
  <h1>Unit Converter</h1>
  <form>
    <label for="main-menu">Select a unit:</label>
    <select id="main-menu" onchange="xh.showSubMenu()">
      <option value="Temperature">Temperature</option>
      <option value="Length">Length</option>
      <option value="Time">Time</option>
      <option value="Mass">Mass</option>
      <option value="Speed">Speed</option>
      <option value="Angle">Angle</option>
    </select>
  </form>
  
  <div id="sub-menu"></div>
  <p></p>
</div>
`
//# sourceURL=MenuScript0.js
]]></DefaultContent></MenuScript0>

  <Avatar><Color>red</Color></Avatar>
</xholonClassDetails>

<ConversionsSystem>
  
  <ConversionsScript/>
  
  <Conversions/>
  
  <TemperatureAI/>
  <LengthAI/>
  <TimeAI/>
  <MassAI/>
  <SpeedAI/>
  <AngleAI/>
  
  <QLength>5 ft</QLength>
  
  <MenuScript/>
  <MenuScript0/>
  
</ConversionsSystem>

<Conversionsbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  const c2f = (c) => (c * 1.8) + 32; // Convert from Celsius to Fahrenheit
  const f2c = (f) => (f - 32) / 1.8; // Convert from Fahrenheit to Celsius
  
  var me, temp, beh = {
    postConfigure: function() {
      me = this.cnode.parent();
      me.println(me.name());
      me.println(this.ctof(100));
      me.println(this.ctoff(37));
      me.println(c2f(-40));
      me.println(f2c(100));
      temp = $wnd.xh.Conversions.Temperature;
    },
    act: function() {
      //me.println(me.name());
      //me.println(temp.cels2fahr(123)); // outputs 253.4
    },
    ctoff: (c) => (c * 1.8) + 32, // celcius to fahrenheit ℉=(℃*1.8)+32
    ctof: function(celcius) {
      return (celcius * 1.8) + 32;
    }
  }
  //# sourceURL=Conversionsbehavior.js
]]></Conversionsbehavior>

<QLengthbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  var me, unit, beh = {
    postConfigure: function() {
      me = this.cnode.parent();
      me.println(me.name()); // qLength_54
      me.println(me.val()); // 5
      me.println(me.text()); // 5 ft
      unit = me.text().trim().split(" ")[1];
      me.println(unit); // ft
      //me.println(me.params());
      console.log(me);
      
    },
    act: function() {
      //me.println(me.name());
      
    }
    //# sourceURL=QLengthbehavior.js
  }
]]></QLengthbehavior>

<SvgClient><Attribute_String roleName="svgUri"><![CDATA[data:image/svg+xml,
<svg width="100" height="50" xmlns="http://www.w3.org/2000/svg">
  <g>
    <title>Conversions</title>
    <rect id="ConversionsSystem/Conversions" fill="#98FB98" height="50" width="50" x="25" y="0"/>
    <g>
      <title>TemperatureAI</title>
      <rect id="ConversionsSystem/TemperatureAI" fill="#6AB06A" height="50" width="10" x="80" y="0"/>
    </g>
  </g>
</svg>
]]></Attribute_String><Attribute_String roleName="setup">${MODELNAME_DEFAULT},${SVGURI_DEFAULT}</Attribute_String></SvgClient>

</XholonWorkbook>