Struct sibyl::Number

pub struct Number<'e> { /* fields omitted */ }

Represents OTS types NUMBER, NUMERIC, INT, SHORTINT, REAL, DOUBLE PRECISION, FLOAT and DECIMAL.

Methods

impl<'e> Number<'e>

pub fn new(env: &'e dyn UsrEnv) -> Self

Returns new uninitialized number.

pub fn zero(env: &'e dyn UsrEnv) -> Self

Creates a new Number that is equal to zero.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::zero(&env);
let is_zero = num.is_zero()?;

assert!(is_zero);

let val: i32 = num.to_int::<i32>()?;

assert_eq!(0, val);

pub fn pi(env: &'e dyn UsrEnv) -> Self

Creates a new Number that is equal to Pi.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let txt = num.to_string("TM")?;

assert_eq!("3.1415926535897932384626433832795028842", txt);

pub fn from_string(txt: &str, fmt: &str, env: &'e dyn UsrEnv) -> Result<Self>

Creates a new Number from a string using specified format.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_string("6.62607004E-34", "9D999999999EEEE", &env)?;
let txt = num.to_string("TME")?;

assert_eq!("6.62607004E-34", txt);

pub fn from_int<T: Integer>(val: T, env: &'e dyn UsrEnv) -> Self

Creates a new Number from any Oracle standard machine-native integer type.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(42, &env);
let val = num.to_int::<i32>()?;

assert_eq!(42, val);

pub fn from_real<T: Real>(val: T, env: &'e dyn UsrEnv) -> Result<Self>

Converts a machine-native floating point type to an Oracle number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.7182818284590452353602874713527, &env)?;
let txt = num.to_string("TM")?;

assert_eq!("2.71828182845905", txt);

pub fn from_number(other: &Number, env: &'e dyn UsrEnv) -> Result<Self>

Creates a "copy" of the other number.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(8128, &env);
let dup = oracle::Number::from_number(&num, &env)?;
let val: i32 = dup.to_int::<i32>()?;

assert_eq!(8128, val);

pub fn assign(&mut self, num: &Number) -> Result<()>

Assigns self the value of the specified number

Example

use sibyl as oracle;

let env = oracle::env()?;
let src = oracle::Number::from_int(33550336, &env);
let mut dst = oracle::Number::zero(&env);
let val: i32 = dst.to_int::<i32>()?;

assert_eq!(0, val);

dst.assign(&src)?;
let val: i32 = dst.to_int::<i32>()?;

assert_eq!(33550336, val);

pub fn to_string(&self, fmt: &str) -> Result<String>

Converts the given number to a character string according to the specified format.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(42, &env);
let txt = num.to_string("FM0G999")?;

assert_eq!("0,042", txt);

pub fn to_int<T: Integer>(&self) -> Result<T>

Converts this Number into a u128, u64, u32, u16, u8, i128, i64, i32, i16, i8 i128 and u128 are not supported by the OCI

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let val = num.to_int::<i32>()?;

assert_eq!(3, val);

pub fn to_real<T: Real>(&self) -> Result<T>

Returns machine-native floating point representation of self

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let val = num.to_real::<f64>()?;

assert!(3.14159265358978 < val && val < 3.14159265358980);

pub fn is_zero(&self) -> Result<bool>

Test if this number is equal to zero

Example

use sibyl as oracle;

let env = oracle::env()?;
let mut num = oracle::Number::zero(&env);

assert!(num.is_zero()?);

num.inc()?;

assert!(!num.is_zero()?);

pub fn is_int(&self) -> Result<bool>

Test if this number is an integer

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::zero(&env);

assert!(num.is_int()?);

let num = oracle::Number::pi(&env);

assert!(!num.is_int()?);

pub fn inc(&mut self) -> Result<()>

It is assumed that the input is an integer between 0 and 100^21-2. If the is input too large, it will be treated as 0 - the result will be an Oracle number 1. If the input is not a positive integer, the result will be unpredictable.

Example

use sibyl as oracle;

let env = oracle::env()?;
let mut num = oracle::Number::zero(&env);
num.inc()?;
let val = num.to_int::<i32>()?;

assert_eq!(1, val);

pub fn dec(&mut self) -> Result<()>

It is assumed that the input is an integer between 0 and 100^21-2. If the is input too large, it will be treated as 0 - the result will be an Oracle number 1. If the input is not a positive integer, the result will be unpredictable.

Example

use sibyl as oracle;

let env = oracle::env()?;
let mut num = oracle::Number::from_int(97, &env);
num.dec()?;
let val = num.to_int::<i32>()?;

assert_eq!(96, val);

pub fn sign(&self) -> Result<Ordering>

Returns sign of a number (as a result of comparing it to zero).

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(19, &env);
let ord = num.sign()?;

assert_eq!(std::cmp::Ordering::Greater as u32, ord as u32);

let num = oracle::Number::from_int(-17, &env);
let ord = num.sign()?;

assert_eq!(std::cmp::Ordering::Less as u32, ord as u32);

let num = oracle::Number::zero(&env);
let ord = num.sign()?;

assert_eq!(std::cmp::Ordering::Equal, ord);

pub fn cmp(&self, num: &Number) -> Result<Ordering>

Compares self to a number.

Example

use sibyl as oracle;

let env = oracle::env()?;
let pi = oracle::Number::pi(&env);
let e = oracle::Number::from_real(2.71828182845905, &env)?;
let cmp = pi.cmp(&e)?;

assert_eq!(std::cmp::Ordering::Greater as u32, cmp as u32);

let cmp = e.cmp(&pi)?;

assert_eq!(std::cmp::Ordering::Less as u32, cmp as u32);

pub fn add(&self, num: &Number) -> Result<Number>

Adds a Number to this Number and returns the sum as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(19, &env);
let arg = oracle::Number::from_int(50, &env);
let res = num.add(&arg)?;
let val = res.to_int::<i32>()?;

assert_eq!(69, val);

pub fn sub(&self, num: &Number) -> Result<Number>

Subtracts a Number from this Number and returns the difference as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(90, &env);
let arg = oracle::Number::from_int(21, &env);
let res = num.sub(&arg)?;
let val = res.to_int::<i32>()?;

assert_eq!(69, val);

pub fn mul(&self, num: &Number) -> Result<Number>

Multiplies a Number to this Number and returns the product as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(3.5, &env)?;
let arg = oracle::Number::from_int(8, &env);
let res = num.mul(&arg)?;

assert!(res.is_int()?);

let val = res.to_int::<i32>()?;

assert_eq!(28, val);

pub fn div(&self, num: &Number) -> Result<Number>

Divides a Number (dividend) by a Number (divisor) and returns the quotient as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(256, &env);
let arg = oracle::Number::from_int(8, &env);
let res = num.div(&arg)?;
let val = res.to_int::<i32>()?;

assert_eq!(32, val);

pub fn rem(&self, num: &Number) -> Result<Number>

Finds the remainder of the division of two Numbers and returns it as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(255, &env);
let arg = oracle::Number::from_int(32, &env);
let res = num.rem(&arg)?;
let val = res.to_int::<i32>()?;

assert_eq!(31, val);

pub fn pow(&self, num: &Number) -> Result<Number>

Raises a number to an arbitrary power and returns the result as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.55, &env)?;
let arg = oracle::Number::from_real(3.2, &env)?;
let res = num.pow(&arg)?;
let val = res.to_real::<f64>()?;

assert!(19.995330061114 < val && val < 19.995330061115);

pub fn powi(&self, num: i32) -> Result<Number>

Raises a number to an integer power and returns the result as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.55, &env)?;
let res = num.powi(3)?;
let val = res.to_real::<f64>()?;

assert!(16.581374999 < val && val < 16.581375001);

pub fn shift(&self, num: i32) -> Result<Number>

Multiplies a number by by a power of 10 and returns the result as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.55, &env)?;
let res = num.shift(2)?;
let val = res.to_int::<i32>()?;

assert_eq!(255, val);

let res = res.shift(-1)?;
let val = res.to_real::<f64>()?;

assert_eq!(25.5, val);

pub fn trunc(&self, num: i32) -> Result<Number>

Truncates a number at a specified decimal place and returns the result as a new Number num is the number of decimal digits to the right of the decimal point to truncate at. Negative values are allowed.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let res = num.trunc(7)?;
let val = res.to_string("TM")?;

assert_eq!("3.1415926", val);

let res = res.shift(5)?;
let val = res.to_real::<f64>()?;

assert_eq!(314159.26, val);

let res = res.trunc(-3)?;
let val = res.to_real::<f64>()?;

assert_eq!(314000.0, val);

pub fn round(&self, num: i32) -> Result<Number>

Rounds a number to a specified decimal place and returns the result as a new Number. num is the number of decimal digits to the right of the decimal point to truncate at. Negative values are allowed.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let res = num.round(7)?;
let val = res.to_string("TM")?;

assert_eq!("3.1415927", val);

pub fn prec(&self, num: i32) -> Result<Number>

Performs a floating point round with respect to the number of digits and returns the result as a new Number. num is the number of decimal digits desired in the result.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let res = num.prec(10)?;
let val = res.to_string("TM")?;

assert_eq!("3.141592654", val);

pub fn neg(&self) -> Result<Number>

Negates a number and returns the result as a new Number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(42, &env);
let res = num.neg()?;
let val = res.to_int::<i32>()?;

assert_eq!(-42, val);

pub fn abs(&self) -> Result<Number>

Returns the absolute value of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(-42, &env);
let res = num.abs()?;
let val = res.to_int::<i32>()?;

assert_eq!(42, val);

pub fn ceil(&self) -> Result<Number>

Returns the smallers integer greater than or equal to a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let res = num.ceil()?;

assert!(res.is_int()?);

let val = res.to_int::<i32>()?;

assert_eq!(4, val);

pub fn floor(&self) -> Result<Number>

Returns the largest integer less than or equal to a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::pi(&env);
let res = num.floor()?;

assert!(res.is_int()?);

let val = res.to_int::<i32>()?;

assert_eq!(3, val);

pub fn sqrt(&self) -> Result<Number>

Returns the square root of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(121, &env);
let res = num.sqrt()?;

assert!(res.is_int()?);

let val = res.to_int::<i32>()?;
assert_eq!(11, val);

pub fn sin(&self) -> Result<Number>

Return the sine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.52359877559, &env)?;
let res = num.sin()?;
let val = res.to_real::<f64>()?;

assert!(0.499999999 < val && val < 0.500000001);

pub fn asin(&self) -> Result<Number>

Return the arcsine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.5, &env)?;
let res = num.asin()?;
let val = res.to_real::<f64>()?;

assert!(0.523598775 < val && val < 0.523598776);

pub fn sinh(&self) -> Result<Number>

Return the hyperbolic sine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.88137358702, &env)?;
let res = num.sinh()?;
let val = res.to_real::<f64>()?;

assert!(0.999999999 < val && val < 1.000000001);

pub fn cos(&self) -> Result<Number>

Return the cosine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(1.0471975512, &env)?;
let res = num.cos()?;
let val = res.to_real::<f64>()?;

assert!(0.499999999 < val && val < 0.500000001);

pub fn acos(&self) -> Result<Number>

Return the arccosine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.5, &env)?;
let res = num.acos()?;
let val = res.to_real::<f64>()?;

assert!(1.047197551 < val && val < 1.047197552);

pub fn cosh(&self) -> Result<Number>

Return the hyperbolic cosine in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.96242365012, &env)?;
let res = num.cosh()?;
let val = res.to_real::<f64>()?;

assert!(1.499999999 < val && val < 1.500000001);

pub fn tan(&self) -> Result<Number>

Return the tangent in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.785398163397, &env)?;
let res = num.tan()?;
let val = res.to_real::<f64>()?;

assert!(0.999999999 < val && val < 1.000000001);

pub fn atan(&self) -> Result<Number>

Return the arctangent in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(1, &env);
let res = num.atan()?;
let val = res.to_real::<f64>()?;

assert!(0.785398163 < val && val < 0.785398164);

pub fn atan2(&self, num: &Number) -> Result<Number>

Returns the four quadrant arctangent of self and num in radians

Example

use sibyl as oracle;

let env = oracle::env()?;
let x = oracle::Number::from_int(4, &env);
let y = oracle::Number::from_int(-3, &env);
let res = x.atan2(&y)?;
let val = res.to_real::<f64>()?;

assert!(2.2142974355 < val && val < 2.2142974356);

pub fn tanh(&self) -> Result<Number>

Returns the hyperbolic tangent in radians of a number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(0.54930614434, &env)?;
let res = num.tanh()?;
let val = res.to_real::<f64>()?;

assert!(0.499999999 < val && val < 0.500000001);

pub fn exp(&self) -> Result<Number>

Returns e^(self) - the exponential function

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.71828182845905, &env)?;
let res = num.exp()?;
let val = res.to_real::<f64>()?;

assert!(15.154262241 < val && val < 15.154262242);

pub fn ln(&self) -> Result<Number>

Returns the natual logarithm of the number

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_real(2.71828182845905, &env)?;
let res = num.ln()?;
let val = res.to_real::<f64>()?;

assert!(0.9999999999 < val && val < 1.0000000001);

pub fn log(&self, num: &Number) -> Result<Number>

Returns the logarithm of the numer using with respect to an arbitrary base.

Example

use sibyl as oracle;

let env = oracle::env()?;
let num = oracle::Number::from_int(65536, &env);
let base = oracle::Number::from_int(4, &env);
let res = num.log(&base)?;
let val = res.to_int::<i32>()?;

assert_eq!(8, val);

pub fn size(&self) -> usize

Trait Implementations

impl<'_> ToSql for Number<'_>

fn to_sql(&self) -> (u16, *const c_void, usize)

Returns a tuple with (SQLT type, pointer to the data buffer, length of the data in the buffer)

impl<'_> ToSqlOut for Number<'_>

fn to_sql_output(&mut self, _col_size: usize) -> (u16, *mut c_void, usize)

Returns output buffer characteristics as a tuple of (SQLT type, buffer pointer, buffer size)

fn set_len(&mut self, _new_len: usize)

Called to set the received data length (always less than the initial capacity)

impl<'a> FromSql<'a> for Number<'a>

fn value(val: &ColumnValue, stmt: &'a dyn Stmt) -> Result<Self>

Converts, if possible, data stored in the column buffer into the requested type and returns the instance of it. Returns error if the conversion fails or not defined from the type of the column buffer into a requested type.