reálné číslo (RealNumber)

Any Number that can be expressed as a (possibly infinite) decimal, i.e. any Number that has a position on the number line.

Ontologie

SUMO / BASE-ONTOLOGY

Nadtřída(y)

entita

abstraktum

veličina

číslo

reálné číslo

Podtřída(y)

racionální číslo iracionální číslo nezáporné reálné číslo záporné reálné číslo binární číslo

Související termín(y)

komplexní číslo imaginární číslo

Constrains relations

absolute value fn arc cosine fn arc sine fn arc tangent fn ceiling fn cosine fn denominator fn floor fn integer square root fn log fn magnitude fn measure fn numerator fn path weight fn probability fn real number fn signum fn sine fn square root fn tangent fn arc weight conditional probability

Related WordNet synsets

real number, real: any rational or irrational number

See more related synsets on a separate page.

Axiomy (49)

číslo je exhaustively partitioned into reálné číslo,imaginární číslo,komplexní číslo.

(partition Number RealNumber ImaginaryNumber ComplexNumber)

less than je trichotomizing on reálné číslo.

(trichotomizingOn lessThan RealNumber)

greater than je trichotomizing on reálné číslo.

(trichotomizingOn greaterThan RealNumber)

less than or equal to je trichotomizing on reálné číslo.

(trichotomizingOn lessThanOrEqualTo RealNumber)

greater than or equal to je trichotomizing on reálné číslo.

(trichotomizingOn greaterThanOrEqualTo RealNumber)

reálné číslo je exhaustively partitioned into záporné reálné číslo,nezáporné reálné číslo.

(partition RealNumber NegativeRealNumber NonnegativeRealNumber)

reálné číslo je exhaustively partitioned into racionální číslo,iracionální číslo.

(partition RealNumber RationalNumber IrrationalNumber)

Jestliže number je instancí třídy imaginární číslo, potom existuje reálné číslo real tak, že number se rovná "real*"square root fn()"".

(=>
      (instance ?NUMBER ImaginaryNumber)
      (exists
            (?REAL)
            (and
                  (instance ?REAL RealNumber)
                  (equal
                        ?NUMBER
                        (MultiplicationFn
                              ?REAL
                              (SquareRootFn -1))))))

number je instancí třídy nezáporné reálné číslo tehdy a jen tehdy pokud number je větší než nebo roven a number je instancí třídy reálné číslo.

(<=>
      (instance ?NUMBER NonnegativeRealNumber)
      (and
            (greaterThanOrEqualTo ?NUMBER 0)
            (instance ?NUMBER RealNumber)))

number je instancí třídy kladné reálné číslo tehdy a jen tehdy pokud number je větší než a number je instancí třídy reálné číslo.

(<=>
      (instance ?NUMBER PositiveRealNumber)
      (and
            (greaterThan ?NUMBER 0)
            (instance ?NUMBER RealNumber)))

number je instancí třídy záporné reálné číslo tehdy a jen tehdy pokud number je menší než a number je instancí třídy reálné číslo.

(<=>
      (instance ?NUMBER NegativeRealNumber)
      (and
            (lessThan ?NUMBER 0)
            (instance ?NUMBER RealNumber)))

komplexní číslo je disjoint from reálné číslo.

(disjoint ComplexNumber RealNumber)

Jestliže number je instancí třídy komplexní číslo, potom existují reálné číslo real1,reálné číslo real2 tak, že number se rovná "(real1+"real2*"square root fn()"")".

(=>
      (instance ?NUMBER ComplexNumber)
      (exists
            (?REAL1 ?REAL2)
            (and
                  (instance ?REAL1 RealNumber)
                  (instance ?REAL2 RealNumber)
                  (equal
                        ?NUMBER
                        (AdditionFn
                              ?REAL1
                              (MultiplicationFn
                                    ?REAL2
                                    (SquareRootFn -1)))))))

"absolute value fn(number1)" se rovná number2 a number1 je instancí třídy reálné číslo a number2 je instancí třídy reálné číslo tehdy a jen tehdy pokud

number1 je instancí třídy nezáporné reálné číslo a number1 se rovná number2
number1 je instancí třídy záporné reálné číslo a number2 se rovná "(-number1)"

(<=>
      (and
            (equal
                  (AbsoluteValueFn ?NUMBER1)
                  ?NUMBER2)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber))
      (or
            (and
                  (instance ?NUMBER1 NonnegativeRealNumber)
                  (equal ?NUMBER1 ?NUMBER2))
            (and
                  (instance ?NUMBER1 NegativeRealNumber)
                  (equal
                        ?NUMBER2
                        (SubtractionFn 0 ?NUMBER1)))))

jestliže rel je instancí třídy relace rozšířená na veličiny a rel je instancí třídy terciální relace a number1 je instancí třídy reálné číslo a number2 je instancí třídy reálné číslo a rel(number1,number2,value) holds,
potom pro všechny unit platí: jestliže unit je instancí třídy měrná jednotka, potom rel("number1 unit(s)","number2 unit(s)","value unit(s)") holds

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL TernaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2 ?VALUE))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)
                        (MeasureFn ?VALUE ?UNIT)))))

jestliže rel je instancí třídy relace rozšířená na veličiny a rel je instancí třídy binární relace a number1 je instancí třídy reálné číslo a number2 je instancí třídy reálné číslo a rel(number1,number2) holds,
potom pro všechny unit platí: jestliže unit je instancí třídy měrná jednotka, potom rel("number1 unit(s)","number2 unit(s)") holds

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL BinaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)))))

Jestliže number je instancí třídy reálné číslo a unit je instancí třídy měrná jednotka, potom "magnitude fn(number unit(s))" se rovná number.

(=>
      (and
            (instance ?NUMBER RealNumber)
            (instance ?UNIT UnitOfMeasure))
      (equal
            (MagnitudeFn
                  (MeasureFn ?NUMBER ?UNIT))
            ?NUMBER))

Jestliže number je instancí třídy reálné číslo, potom "number centimeter(s)" se rovná ""number*" meter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Centimeter)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  Meter)))

Jestliže number je instancí třídy reálné číslo, potom "number celsius degree(s)" se rovná ""(number-)" kelvin degree(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER CelsiusDegree)
            (MeasureFn
                  (SubtractionFn ?NUMBER 273.15)
                  KelvinDegree)))

Jestliže number je instancí třídy reálné číslo, potom "number celsius degree(s)" se rovná """(number-)"/" fahrenheit degree(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER CelsiusDegree)
            (MeasureFn
                  (DivisionFn
                        (SubtractionFn ?NUMBER 32)
                        1.8)
                  FahrenheitDegree)))

Jestliže number je instancí třídy reálné číslo, potom "number day duration(s)" se rovná ""number*" hour duration(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER DayDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 24)
                  HourDuration)))

Jestliže number je instancí třídy reálné číslo, potom "number hour duration(s)" se rovná ""number*" minute duration(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER HourDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 60)
                  MinuteDuration)))

Jestliže number je instancí třídy reálné číslo, potom "number minute duration(s)" se rovná ""number*" second duration(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER MinuteDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 60)
                  SecondDuration)))

Jestliže number je instancí třídy reálné číslo, potom "number week duration(s)" se rovná ""number*" day duration(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER WeekDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 7)
                  DayDuration)))

Jestliže number je instancí třídy reálné číslo, potom "number year duration(s)" se rovná ""number*" day duration(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER YearDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 365)
                  DayDuration)))

Jestliže number je instancí třídy reálné číslo, potom "number amu(s)" se rovná ""number**" gram(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Amu)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.6605402 E-24)
                  Gram)))

Jestliže number je instancí třídy reálné číslo, potom "number electron volt(s)" se rovná ""number**" joule(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER ElectronVolt)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.60217733 E-19)
                  Joule)))

Jestliže number je instancí třídy reálné číslo, potom "number angstrom(s)" se rovná ""number**" meter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Angstrom)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.0 E-10)
                  Meter)))

Jestliže number je instancí třídy reálné číslo, potom "number foot(s)" se rovná ""number*" meter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Foot)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.3048)
                  Meter)))

Jestliže number je instancí třídy reálné číslo, potom "number inch(s)" se rovná ""number*" meter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Inch)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.0254)
                  Meter)))

Jestliže number je instancí třídy reálné číslo, potom "number mile(s)" se rovná ""number*" meter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Mile)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1609.344)
                  Meter)))

Jestliže number je instancí třídy reálné číslo, potom "number united states gallon(s)" se rovná ""number*" liter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedStatesGallon)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 3.785411784)
                  Liter)))

Jestliže number je instancí třídy reálné číslo, potom "number quart(s)" se rovná ""number/" united states gallon(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Quart)
            (MeasureFn
                  (DivisionFn ?NUMBER 4)
                  UnitedStatesGallon)))

Jestliže number je instancí třídy reálné číslo, potom "number pint(s)" se rovná ""number/" quart(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Pint)
            (MeasureFn
                  (DivisionFn ?NUMBER 2)
                  Quart)))

Jestliže number je instancí třídy reálné číslo, potom "number cup(s)" se rovná ""number/" pint(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Cup)
            (MeasureFn
                  (DivisionFn ?NUMBER 2)
                  Pint)))

Jestliže number je instancí třídy reálné číslo, potom "number ounce(s)" se rovná ""number/" cup(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Ounce)
            (MeasureFn
                  (DivisionFn ?NUMBER 8)
                  Cup)))

Jestliže number je instancí třídy reálné číslo, potom "number united kingdom gallon(s)" se rovná ""number*" liter(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedKingdomGallon)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.54609)
                  Liter)))

Jestliže number je instancí třídy reálné číslo, potom "number pound mass(s)" se rovná ""number*" gram(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER PoundMass)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 453.59237)
                  Gram)))

Jestliže number je instancí třídy reálné číslo, potom "number slug(s)" se rovná ""number*" gram(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Slug)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 14593.90)
                  Gram)))

Jestliže number je instancí třídy reálné číslo, potom "number rankine degree(s)" se rovná ""number*" kelvin degree(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER RankineDegree)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.8)
                  KelvinDegree)))

Jestliže number je instancí třídy reálné číslo, potom "number pound force(s)" se rovná ""number*" newton(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER PoundForce)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.448222)
                  Newton)))

Jestliže number je instancí třídy reálné číslo, potom "number calorie(s)" se rovná ""number*" joule(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Calorie)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.1868)
                  Joule)))

Jestliže number je instancí třídy reálné číslo, potom "number british thermal unit(s)" se rovná ""number*" joule(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER BritishThermalUnit)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1055.05585262)
                  Joule)))

Jestliže number je instancí třídy reálné číslo, potom "number angular degree(s)" se rovná ""number*"pi/"" radian(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER AngularDegree)
            (MeasureFn
                  (MultiplicationFn
                        ?NUMBER
                        (DivisionFn Pi 180))
                  Radian)))

Jestliže number je instancí třídy reálné číslo, potom "number united states cent(s)" se rovná ""number*" united states dollar(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedStatesCent)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  UnitedStatesDollar)))

Jestliže number je instancí třídy reálné číslo, potom "number euro cent(s)" se rovná ""number*" euro dollar(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER EuroCent)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  EuroDollar)))

Jestliže number je instancí třídy reálné číslo, potom "number byte(s)" se rovná ""number*" bit(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Byte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 8)
                  Bit)))

Jestliže number je instancí třídy reálné číslo, potom "number kilo byte(s)" se rovná ""number*" byte(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER KiloByte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1024)
                  Byte)))

Jestliže number je instancí třídy reálné číslo, potom "number mega byte(s)" se rovná ""number*" kilo byte(s)".

(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER MegaByte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1024)
                  KiloByte)))