Select language: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Concept: English word: Home

# measure fn (MeasureFn)

This BinaryFunction maps a RealNumber and a UnitOfMeasure to that Number of units. It is used for expressing ConstantQuantities. For example, the concept of three meters is represented as (MeasureFn 3 Meter).

## Ontology

SUMO / UNITS-OF-MEASURE

## Class(es)

 Classe

inheritable relation

FunzioneBinaria

measure fn

## Coordinate term(s)

addition fn  day fn  density fn  division fn  edition fn  exponentiation fn  graph path fn  hour fn  intersection fn  interval fn  kappa fn  list concatenate fn  list order fn  log fn  max fn  maximal weighted path fn  mereological difference fn  mereological product fn  mereological sum fn  min fn  minimal weighted path fn  minute fn  month fn  multiplication fn  periodical issue fn  recurrent time interval fn  relative complement fn  relative time fn  remainder fn  second fn  series volume fn  speed fn  subtraction fn  temporal composition fn  time interval fn  union fn  where fn

## Type restrictions

QuantitáCostante MeasureFn(NumeroReale, UnitáDiMisura)

## Axioms (71)

Se "number unit(s" is uguale a quant e unit é una sottoclasse di quanttype, allora quant é un' istanza di quanttype.
```(=>
(and
(equal
(MeasureFn ?NUMBER ?UNIT)
?QUANT)
(subclass ?UNIT ?QUANTTYPE))
(instance ?QUANT ?QUANTTYPE))```

```(=>
(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)))))```

```(=>
(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)))))```

Se unit é un' istanza di UnitáDiMisura, allora "1 mille units" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(KiloFn ?UNIT)
(MeasureFn 1000 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "1 milione units" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MegaFn ?UNIT)
(MeasureFn 1000000 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "1 miliardo units " is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(GigaFn ?UNIT)
(MeasureFn 1000000000 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "1 trilione units" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(TeraFn ?UNIT)
(MeasureFn 1000000000000 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "unmillesimo di un unit" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MilliFn ?UNIT)
(MeasureFn 0.001 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "un milionesimo di unit" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MicroFn ?UNIT)
(MeasureFn 0.000001 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "un miliardesimo di un unit" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(NanoFn ?UNIT)
(MeasureFn 0.000000001 ?UNIT)))```

Se unit é un' istanza di UnitáDiMisura, allora "un trilionesimo di un unit" is uguale a " unit(s".
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(PicoFn ?UNIT)
(MeasureFn 0.000000000001 ?UNIT)))```

Se number é un' istanza di NumeroReale e unit é un' istanza di UnitáDiMisura, allora "la magnitudine di "number unit(s"" is uguale a number.
```(=>
(and
(instance ?NUMBER RealNumber)
(instance ?UNIT UnitOfMeasure))
(equal
(MagnitudeFn
(MeasureFn ?NUMBER ?UNIT))
?NUMBER))```

Se number é un' istanza di NumeroReale, allora "number centimeter(s" is uguale a ""number*" meter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Centimeter)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
Meter)))```

Se number é un' istanza di NumeroReale, allora "number celsius degree(s" is uguale a ""(number-" kelvin degree(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(SubtractionFn ?NUMBER 273.15)
KelvinDegree)))```

Se number é un' istanza di NumeroReale, allora "number celsius degree(s" is uguale a """(number-"/" fahrenheit degree(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(DivisionFn
(SubtractionFn ?NUMBER 32)
1.8)
FahrenheitDegree)))```

Se number é un' istanza di NumeroReale, allora "number day duration(s" is uguale a ""number*" hour duration(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER DayDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 24)
HourDuration)))```

Se number é un' istanza di NumeroReale, allora "number hour duration(s" is uguale a ""number*" minute duration(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER HourDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
MinuteDuration)))```

Se number é un' istanza di NumeroReale, allora "number minute duration(s" is uguale a ""number*" second duration(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MinuteDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
SecondDuration)))```

Se number é un' istanza di NumeroReale, allora "number week duration(s" is uguale a ""number*" day duration(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER WeekDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 7)
DayDuration)))```

Se number é un' istanza di NumeroReale, allora "number year duration(s" is uguale a ""number*" day duration(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER YearDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 365)
DayDuration)))```

Se number é un' istanza di NumeroReale, allora "number amu(s" is uguale a ""number**" gram(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Amu)
(MeasureFn
(MultiplicationFn ?NUMBER 1.6605402 E-24)
Gram)))```

Se number é un' istanza di NumeroReale, allora "number electron volt(s" is uguale a ""number**" joule(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER ElectronVolt)
(MeasureFn
(MultiplicationFn ?NUMBER 1.60217733 E-19)
Joule)))```

Se number é un' istanza di NumeroReale, allora "number angstrom(s" is uguale a ""number**" meter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Angstrom)
(MeasureFn
(MultiplicationFn ?NUMBER 1.0 E-10)
Meter)))```

Se number é un' istanza di NumeroReale, allora "number foot(s" is uguale a ""number*" meter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Foot)
(MeasureFn
(MultiplicationFn ?NUMBER 0.3048)
Meter)))```

Se number é un' istanza di NumeroReale, allora "number inch(s" is uguale a ""number*" meter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Inch)
(MeasureFn
(MultiplicationFn ?NUMBER 0.0254)
Meter)))```

Se number é un' istanza di NumeroReale, allora "number mile(s" is uguale a ""number*" meter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Mile)
(MeasureFn
(MultiplicationFn ?NUMBER 1609.344)
Meter)))```

Se number é un' istanza di NumeroReale, allora "number united states gallon(s" is uguale a ""number*" liter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 3.785411784)
Liter)))```

Se number é un' istanza di NumeroReale, allora "number quart(s" is uguale a ""number/" united states gallon(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Quart)
(MeasureFn
(DivisionFn ?NUMBER 4)
UnitedStatesGallon)))```

Se number é un' istanza di NumeroReale, allora "number pint(s" is uguale a ""number/" quart(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Pint)
(MeasureFn
(DivisionFn ?NUMBER 2)
Quart)))```

Se number é un' istanza di NumeroReale, allora "number cup(s" is uguale a ""number/" pint(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Cup)
(MeasureFn
(DivisionFn ?NUMBER 2)
Pint)))```

Se number é un' istanza di NumeroReale, allora "number ounce(s" is uguale a ""number/" cup(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Ounce)
(MeasureFn
(DivisionFn ?NUMBER 8)
Cup)))```

Se number é un' istanza di NumeroReale, allora "number united kingdom gallon(s" is uguale a ""number*" liter(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedKingdomGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 4.54609)
Liter)))```

Se number é un' istanza di NumeroReale, allora "number pound mass(s" is uguale a ""number*" gram(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundMass)
(MeasureFn
(MultiplicationFn ?NUMBER 453.59237)
Gram)))```

Se number é un' istanza di NumeroReale, allora "number slug(s" is uguale a ""number*" gram(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Slug)
(MeasureFn
(MultiplicationFn ?NUMBER 14593.90)
Gram)))```

Se number é un' istanza di NumeroReale, allora "number rankine degree(s" is uguale a ""number*" kelvin degree(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER RankineDegree)
(MeasureFn
(MultiplicationFn ?NUMBER 1.8)
KelvinDegree)))```

Se number é un' istanza di NumeroReale, allora "number pound force(s" is uguale a ""number*" newton(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundForce)
(MeasureFn
(MultiplicationFn ?NUMBER 4.448222)
Newton)))```

Se number é un' istanza di NumeroReale, allora "number calorie(s" is uguale a ""number*" joule(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Calorie)
(MeasureFn
(MultiplicationFn ?NUMBER 4.1868)
Joule)))```

Se number é un' istanza di NumeroReale, allora "number british thermal unit(s" is uguale a ""number*" joule(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER BritishThermalUnit)
(MeasureFn
(MultiplicationFn ?NUMBER 1055.05585262)
Joule)))```

Se number é un' istanza di NumeroReale, allora "number angular degree(s" is uguale a ""number*"PiGreco/"" radian(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER AngularDegree)
(MeasureFn
(MultiplicationFn
?NUMBER
(DivisionFn Pi 180))

Se number é un' istanza di NumeroReale, allora "number united states cent(s" is uguale a ""number*" united states dollar(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
UnitedStatesDollar)))```

Se number é un' istanza di NumeroReale, allora "number euro cent(s" is uguale a ""number*" euro dollar(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER EuroCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
EuroDollar)))```

Se number é un' istanza di NumeroReale, allora "number byte(s" is uguale a ""number*" bit(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Byte)
(MeasureFn
(MultiplicationFn ?NUMBER 8)
Bit)))```

Se number é un' istanza di NumeroReale, allora "number kilo byte(s" is uguale a ""number*" byte(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER KiloByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
Byte)))```

Se number é un' istanza di NumeroReale, allora "number mega byte(s" is uguale a ""number*" kilo byte(s".
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MegaByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
KiloByte)))```

```(=>
(larger ?OBJ1 ?OBJ2)
(forall
(?QUANT1 ?QUANT2)
(=>
(and
(measure
?OBJ1
(MeasureFn ?QUANT1 LengthMeasure))
(measure
?OBJ2
(MeasureFn ?QUANT2 LengthMeasure)))
(greaterThan ?QUANT1 ?QUANT2))))```

Se year é un' istanza di Anno, allora durata di year é " year duration(s".
```(=>
(instance ?YEAR Year)
(duration
?YEAR
(MeasureFn 1 YearDuration)))```

Se leap é un' istanza di AnnoBisestile e leap is uguale a "number Anno(s", allora
```(=>
(and
(instance ?LEAP LeapYear)
(equal
?LEAP
(MeasureFn ?NUMBER Year)))
(or
(and
(equal
(RemainderFn ?NUMBER 4)
0)
(not
(equal
(RemainderFn ?NUMBER 100)
0)))
(equal
(RemainderFn ?NUMBER 400)
0)))```

Se month é un' istanza di Gennaio, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH January)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se "il mese Febbraio" is uguale a month e year é not un' istanza di AnnoBisestile, allora durata di month é " day duration(s".
```(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(not
(instance ?YEAR LeapYear)))
(duration
?MONTH
(MeasureFn 28 DayDuration)))```

Se "il mese Febbraio" is uguale a month e year é un' istanza di AnnoBisestile, allora durata di month é " day duration(s".
```(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(instance ?YEAR LeapYear))
(duration
?MONTH
(MeasureFn 29 DayDuration)))```

Se month é un' istanza di Marzo, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH March)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se month é un' istanza di Aprile, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH April)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Se month é un' istanza di Maggio, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH May)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se month é un' istanza di Giugno, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH June)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Se month é un' istanza di Luglio, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH July)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se month é un' istanza di Agosto, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH August)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se month é un' istanza di Settembre, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH September)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Se month é un' istanza di Ottobre, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH October)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se month é un' istanza di Novembre, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH November)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Se month é un' istanza di Dicembre, allora durata di month é " day duration(s".
```(=>
(instance ?MONTH December)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Se day é un' istanza di Giorno, allora durata di day é " day duration(s".
```(=>
(instance ?DAY Day)
(duration
?DAY
(MeasureFn 1 DayDuration)))```

Se week é un' istanza di Settimana, allora durata di week é " week duration(s".
```(=>
(instance ?WEEK Week)
(duration
?WEEK
(MeasureFn 1 WeekDuration)))```

Se hour é un' istanza di Ora, allora durata di hour é " hour duration(s".
```(=>
(instance ?HOUR Hour)
(duration
?HOUR
(MeasureFn 1 HourDuration)))```

Se minute é un' istanza di Minuto, allora durata di minute é " minute duration(s".
```(=>
(instance ?MINUTE Minute)
(duration
?MINUTE
(MeasureFn 1 MinuteDuration)))```

Se second é un' istanza di Secondo, allora durata di second é " second duration(s".
```(=>
(instance ?SECOND Second)
(duration
?SECOND
(MeasureFn 1 SecondDuration)))```

Se month é un' istanza di Mese e durata di month é "number day duration(s", allora "il numero di istanzia in "decomposizione di month in ? Giornos"" is uguale a number.
```(=>
(and
(instance ?MONTH Month)
(duration
?MONTH
(MeasureFn ?NUMBER DayDuration)))
(equal
(CardinalityFn
(TemporalCompositionFn ?MONTH Day))
?NUMBER))```

Se increase é un' istanza di Aumento e obj é un paziente di increase, allora esiste unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di increase"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di increase"" e quant2 é più grande di quant1.
```(=>
(and
(instance ?INCREASE Increasing)
(patient ?INCREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))```

Se heat é un' istanza di Riscaldamento e obj é un paziente di heat, allora esiste MisuraDiTemperatura unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di heat"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di heat"" e quant2 é più grande di quant1.
```(=>
(and
(instance ?HEAT Heating)
(patient ?HEAT ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))```

Se decrease é un' istanza di Diminuzione e obj é un paziente di decrease, allora esiste unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di decrease"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di decrease"" e quant2 é meno diquant1.
```(=>
(and
(instance ?DECREASE Decreasing)
(patient ?DECREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))```

Se cool é un' istanza di Raffreddamento e obj é un paziente di cool, allora esiste MisuraDiTemperatura unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di cool"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di cool"" e quant2 é meno diquant1.
```(=>
(and
(instance ?COOL Cooling)
(patient ?COOL ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))```

Se meas é un' istanza di Misurare e meas é un agente di agent e obj é un paziente di meas, allora esiste quant,unit tale che "agent conosces "lamisura obj é "quant unit(s""" vales durante "immediatamente dopo "il tempo di esistenza di meas"".
```(=>
(and
(instance ?MEAS Measuring)
(agent ?MEAS ?AGENT)
(patient ?MEAS ?OBJ))
(exists
(?QUANT ?UNIT)
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MEAS))
(knows
?AGENT
(measure
?OBJ
(MeasureFn ?QUANT ?UNIT))))))```