sirtimbly/IronCalc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor updates to Error Types and Value Types documentation

Browse Source
This commit is contained in:
Steve Fanning
2024-12-21 17:47:06 +00:00
committed by Nicolás Hatcher Andrés
parent df4b4ca353
commit de997f38f5
2 changed files with 40 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
docs/src/features/error-types.md
View File

@@ -11,11 +11,11 @@ lang: en-US
:::
The result of a formula is sometimes an _error_. In some situations those errors are expected and your formulas might be dealing with them.
The error `#N/A` might signal that there is no data to evaluate the formula yet. Maybe the payrol has not been introduced for that month just yet.
The error `#N/A` might signal that there is no data to evaluate the formula yet. Maybe the payroll has not been introduced for that month just yet.
Some other errors like `#SPILL!`, `#CIRC!` or `#ERROR!` signal an error in your spreadsheet logic and must be corrected.
The first kind of errors or 'common errors' are found in other spreadsheet engines like Excel while other errrors like `#ERROR!` or `#N/IMPL` are particular to IronCalc.
The first kind of errors or 'common errors' are found in other spreadsheet engines like Excel while other errors like `#ERROR!` or `#N/IMPL` are particular to IronCalc.
## Common Errors
@@ -24,7 +24,7 @@ The first kind of errors or 'common errors' are found in other spreadsheet engin
It might be caused by mismatched data types (e.g., text used where numbers are expected):
```
5+"two"
=5+"two"
```
The engine doesn't know how to add the number `5` to the string `two` resulting in a `#VALUE!`.
@@ -33,13 +33,13 @@ It is an actual error in your spreadsheet. It indicates that the formula isn’t
### **`#DIV/0!`**
Division by zero or an empty cell.
Division by zero or an empty cell:
```
=1/0
```
Usually this is an error. However, in cases where a denominator might be blank (e.g., data not yet filled in), this could be expected. Use `IFERROR` or `IF` to handle it.
Usually this is an error. However, in cases where a denominator might be blank (e.g., data not yet filled in), this could be expected. Use `IFERROR` or `IF` to handle it:
```
=IF(B1=0, "N/A", A1/B1)
@@ -47,10 +47,10 @@ Usually this is an error. However, in cases where a denominator might be blank (
### **`#NAME?`**
Found when a name is not recognized. Maybe a misspeled name for a function. Could be a referenceto defined name that has been deleted.
Found when a name is not recognized. Maybe a misspelled name for a function or a reference to a previously defined name that has since been deleted:
```
=UNKOWN_FUNCTION(A1)
=UNKNOWN_FUNCTION(A1)
```
This indicates an error in your spreadsheet logic.
@@ -59,7 +59,7 @@ This indicates an error in your spreadsheet logic.
Indicates an invalid cell reference, often from deleting cells used in a formula.
They can appear as a result of a computation or in a formula. Examples:
They can appear as a result of a computation or in a formula. Example:
```
=Sheet34!A1
@@ -71,16 +71,16 @@ This is a genuine error. It indicates that part of your formula references a cel
### **`#NUM!`**
Invalid numeric operation (e.g., calculating a square root of a negative number).
Invalid numeric operation (e.g., calculating the square root of a negative number).
Adjust the formula to ensure valid numeric operations.
Sometimes a `#NUM!` might be expected signalling the user that some parameter is out of scope.
Sometimes a `#NUM!` error might be expected, signalling to the user that some parameter is out of scope.
### **`#N/A`**
A value is not available, often in lookup functions like VLOOKUP.
This is frequnly not an error in your spreadsheetlogic.
This is frequently not an error in your spreadsheet logic.
You can produce a prettier answer using the [`IFNA`](/functions/information/isna) formula:
@@ -95,16 +95,16 @@ Incorrect range operator in a formula (e.g., missing a colon between cell refere
### **`#SPILL!`**
A cell in a formula will overwrite content in other cells.
This cannot happen riht now in IronCalc as formulas don't spill yet.
This cannot happen right now in IronCalc as formulas don't spill yet.
### **`#CIRC!`**
Circular reference. This is an error is your spreadsheet and must be fixed.
Means that during teh course of a computation a circular dependency was found.
Circular reference. This is an error in your spreadsheet and must be fixed.
It means that during the course of a computation, a circular dependency was found.
A circular dependency is a dependency of a formula on itself.
For instance in the cell `A1` the formula `=A1*2` is a circular dependency.
For instance, in the cell `A1` the formula `=A1*2` is a circular dependency.
Other spreadsheet engines use circular dependencies to do "loop computations", run "sensitivity analysis" or "goal seek".
@@ -112,35 +112,29 @@ IronCalc doesn't support any of those at the moment.
## IronCalc specific errors
---
### **`#ERROR!`**
General formula issue, like syntax errors or invalid references.
In general Excel does not let you enter incorrect formulas but IronCalc will.
In general, Excel does not let you enter incorrect formulas, but IronCalc will.
This will make your workbook imcompatible with Excel
This will make your workbook imcompatible with Excel.
For instace an incomplete formula
```
=A1+
```
Typical examples might be an incomplete formula, such as `=A1+`, or a function call with too few arguments, such as `=FV(1,2)`.
### **`#N/IMPL!`**
A particular feature is not yet implemented in IronCalc
Look if there is a Github ticket or contact us via email, Discord or bluesky
Check if there is a [Github](https://github.com/ironcalc) ticket or contact us via [email](mailto:hello@ironcalc.com) or [Discord](https://discord.com/invite/zZYWfh3RHJ).
## Error propagation
Some errors a created by some formulas. For instance the function `SQRT` can create the error `#NUM!` but can't ceate the error `#DIV/0`.
Some errors are created by some formulas. For instance, the function `SQRT` can create the error `#NUM!`, but can't ceate the error `#DIV/0`.
Once an error is created it is normally _propagated_ by all the formulas. So if cell `C3` evaluates to `#ERROR!` then the formula
Once an error is created it is normally _propagated_ by all the formulas. So if cell `C3` evaluates to `#ERROR!`, then the formula
`=SQRT(C3)` will return `#ERROR!`.
Not all functions propagate errors in their arguments. For instancethe function `IF(condition, if_true, if_false)` will only propagate an error in the `if_false` argument if the `condition` is `FALSE`. This is called _lazy evaluation_, the function `IF` is _lazy_, it only evaluates the arguments when needed. The opposite of lazy evaulaution is called _eager evaluation_.
Not all functions propagate errors in their arguments. For instance the function `IF(condition, if_true, if_false)` will only propagate an error in the `if_false` argument if the `condition` is `FALSE`. This is called _lazy evaluation_ - the function `IF` is _lazy_ because it only evaluates the arguments when needed. The opposite of lazy evaulaution is called _eager evaluation_.
Some functions also expect an error as an argument like [`ERROR.TYPE`](/functions/information/error.type) and will not propagate the error.
@@ -154,4 +148,4 @@ The following functions are convenient when working with errors
- [`ISNA(ref)`](/functions/information/isna), `TRUE` if ref is `#N/A`.
- [`ERROR.TYPE`](/functions/information/error.type) returns the numeric code for a given error.
- [`IFERROR(ref, value)`](/functions/logical/iferror) returns `value` if the content of `ref` is an error.
- [`IFNA(ref, value)`](/functions/logical/ifna) return `value` if `ref` is #N/A errors only.
- [`IFNA(ref, value)`](/functions/logical/ifna) returns `value` only if the content of `ref` is the `#N/A` error.

32
docs/src/features/value-types.md
View File

@@ -10,47 +10,49 @@ lang: en-US
**Note:** This draft page is under construction 🚧
:::
In IronCalc a value, a result of a calculation can be one of:
In IronCalc a value, a result of a calculation, can be one of the following.
## Numbers
Numbers in IronCalc are [IEEE 754 double precission](https://en.wikipedia.org/wiki/Double-precision_floating-point_format).
Numbers in IronCalc are [IEEE 754 double-precision](https://en.wikipedia.org/wiki/Double-precision_floating-point_format).
Numbers are only displayed up to 15 significant figures. That's why '=0.1+0.2' is actually '0.3'
Numbers are only displayed up to 15 significant figures. That's why `=0.1+0.2` gives `0.3`.
Also numbers are compared up to 15 significant figures. So `=IF(0.1+0.2=0.3, "Valid", "Invalid")` will return `Valid`.
Also, numbers are compared up to 15 significant figures. So `=IF(0.1+0.2=0.3, "Valid", "Invalid")` gives `Valid`.
However `=0.3-0.2-0.1` will not result in `0` in IronCalc.
However, `=0.3-0.2-0.1` will not give exactly `0` in IronCalc.
### Casting into numbers
Strings and booleans are sometimes coverted to numbers
Strings and booleans are sometimes converted to numbers:
`=1+"2"` => 3
`=1+"2"` => `3`
Some functions cast in weird ways:
SUM(1, TRUE) => 2
SUM(1, "1") => 2
`=SUM(1,TRUE)` => `1` and `=SUM(1,"1")` => `1`
But SUM(1, A1) => 1 (where A1 is TRUE or "1")
And `=SUM(1,A1)` => `1` (where A1 contains `TRUE` or `"1"`)
Sometimes the conversion happens like => "123"+1 is actually 124 and the SQRT("4") is 2 or the SQRT(TRUE) is 1.
Sometimes the conversion happens as might be expected. For example, `="123"+1` is `124`, `=SQRT("4")` is `2` and `=SQRT(TRUE)` is `1`.
Some functions, however are more strict BIN2DEC(TRUE) is #VALUE!
Some functions, however, are more strict. For example, `=BIN2DEC(TRUE)` gives the #VALUE! error.
### Dates
### Dates and times
On spreadsheets a date is just the number of days since January 1, 1900.
IronCalc uses numbers to represent dates and times.
The integer part of the number represents the date, as a count of days since the fixed starting date of December 30, 1899.
The fractional part of the number represents the time of day. 0.0 corresponds to 00:00:00 (midnight) and 0.5 corresponds to 12:00:00 (noon).
## Strings
### Complex numbers
On IronCal a complex number is just a string like "1+j3".
Using IronCalc, a complex number is a string of the form "1+j3".
## Booleans