GWY_FREE_VALUE_FORMAT()

#define             GWY_FREE_VALUE_FORMAT(vf)

Frees and nulls a pointer to a GwyValueFormat if it exists.

The value format must have been created using a gwy_unit_get_format(), gwy_field_get_value_format_z() or a similar function.

If vf is not NULL, gwy_value_format_free() is called on it, freeing also string data, and NULL is assigned to the variable. In all cases vf will be NULL at the end.

A useful property of this macro is its idempotence.

gwy_unit_new()

GwyUnit *
gwy_unit_new (const gchar *unit_string);

Creates a new unit from string representation.

Unit string represents unit with no prefixes (e. g. "m", "N", "A", etc.)

[constructor]

gwy_unit_new_parse()

GwyUnit *
gwy_unit_new_parse (const gchar *unit_string,
                    gint *power10);

Creates a new unit from string representation.

This is a more powerful version of gwy_unit_new(): unit_string may be a relatively complex unit, with prefixes, like "pA/s" or "km^2". Beside conversion to a base unit like "A/s" or "m^2" it also computes the power of 10 one has to multiply the base unit with to get an equivalent of unit_string .

For example, for "pA/s" it will store -12 to power10 because 1 pA/s is 1e-12 A/s, for "km^2" it will store 6 to power10 because 1 km^2 is 1e6 m^2.

gwy_unit_clear()

void
gwy_unit_clear (GwyUnit *unit);

Sets a unit to empty.

gwy_unit_set_from_string()

gint
gwy_unit_set_from_string (GwyUnit *unit,
                          const gchar *unit_string);

Changes an unit according to string representation.

See gwy_unit_new_parse() for a discussion of the returned power of 10.

The string can be NULL to make the unit empty, but you can just use gwy_unit_clear() then.

gwy_unit_get_string()

gchar *
gwy_unit_get_string (GwyUnit *unit,
                     GwyUnitFormatStyle style);

Obtains string representing a unit.

gwy_unit_multiply()

GwyUnit *
gwy_unit_multiply (GwyUnit *unit,
                   GwyUnit *operand1,
                   GwyUnit *operand2);

Sets a unit to the product of two other units.

It is possible to pass either of operand1 and operand2 (or even both) as unit .

gwy_unit_divide()

GwyUnit *
gwy_unit_divide (GwyUnit *unit,
                 GwyUnit *operand1,
                 GwyUnit *operand2);

Sets a unit to the ratio of two other units.

It is possible to pass either of operand1 and operand2 (or even both) as unit .

gwy_unit_power()

GwyUnit *
gwy_unit_power (GwyUnit *unit,
                GwyUnit *operand,
                gint power);

Sets a unit to an integer power of another unit.

It is possible to pass operand as unit .

gwy_unit_nth_root()

gboolean
gwy_unit_nth_root (GwyUnit *unit,
                   GwyUnit *operand,
                   gint ipower);

Sets a unit to the the n-th root of another unit.

The operation fails if the result would have fractional powers that are not representable by GwyUnit.

It is possible to pass operand as unit .

gwy_unit_power_multiply()

GwyUnit *
gwy_unit_power_multiply (GwyUnit *unit,
                         GwyUnit *operand1,
                         gint power1,
                         GwyUnit *operand2,
                         gint power2);

Sets a unit to the product of two other units raised to arbitrary integer powers.

It is possible to pass either of operand1 and operand2 (or even both) as unit .

gwy_unit_factor_to_base()

GwyUnit *
gwy_unit_factor_to_base (GwyUnit *unit,
                         GwyUnit *result,
                         gdouble *mfactor);

Factors a possibly derived unit to base units.

For instance, if unit was set to "N/m" the result will be "kg/s^2".

Normally the result will consist only of the base seven units. However, recognised non-units (and pseudounits) in unit , such as "px" are left intact in the decomposition.

Also note that the decomposition is done to prefixable units. Kilogram is not prefixable (gram is) and there is no general way to keep the kilo- on the kilograms when deriving units for different powers of 10. Therefore, the calculated factor corresponds to decomposition to grams.

You must multiply the corresponding data with factor if you intend to use the result for them instead of unit !

gwy_unit_equal()

gboolean
gwy_unit_equal (GwyUnit *unit,
                GwyUnit *operand);

Checks whether two units are equal.

gwy_unit_equal_string()

gboolean
gwy_unit_equal_string (GwyUnit *unit,
                       const gchar *unit_string);

Checks whether an unit corresponds to given string.

Any power-of-ten prefixes are ignored. This function is mostly useful for quick commensurability checks with simple units such as "m" and for checking whether a unit is non-empty (by comparing with NULL or an empty string).

gwy_unit_get_format()

GwyValueFormat *
gwy_unit_get_format (GwyUnit *unit,
                     GwyUnitFormatStyle style,
                     gdouble value,
                     GwyValueFormat *format);

Finds a good format for representing a value.

The values should be then printed as value/format->magnitude [format->units ] with format->precision decimal places.

gwy_unit_get_format_for_power10()

GwyValueFormat *
gwy_unit_get_format_for_power10 (GwyUnit *unit,
                                 GwyUnitFormatStyle style,
                                 gint power10,
                                 GwyValueFormat *format);

Finds format for representing a specific power-of-10 multiple of a unit.

The values should be then printed as value/format->magnitude [format->units ] with format->precision decimal places.

This function does not change the precision field of format .

gwy_unit_get_format_with_resolution()

GwyValueFormat *
gwy_unit_get_format_with_resolution (GwyUnit *unit,
                                     GwyUnitFormatStyle style,
                                     gdouble maximum,
                                     gdouble resolution,
                                     GwyValueFormat *format);

Finds a good format for representing a range of values with given resolution.

The values should be then printed as value/format->magnitude [format->units ] with format->precision decimal places.

gwy_unit_get_format_with_digits()

GwyValueFormat *
gwy_unit_get_format_with_digits (GwyUnit *unit,
                                 GwyUnitFormatStyle style,
                                 gdouble maximum,
                                 gint sdigits,
                                 GwyValueFormat *format);

Finds a good format for representing a values with given number of significant digits.

The values should be then printed as value/format->magnitude [format->units ] with format->precision decimal places.

gwy_unit_copy()

GwyUnit *
gwy_unit_copy (GwyUnit *unit);

Create a new unit as a copy of an existing one.

This function is a convenience gwy_serializable_copy() wrapper.

gwy_unit_assign()

void
gwy_unit_assign (GwyUnit *destination,
                 GwyUnit *source);

Makes one unit equal to another.

This function is a convenience gwy_serializable_assign() wrapper.

enum GwyUnitFormatStyle

Physical quantity formatting style.

The VF-variants differ from tne non-VF ones by a multiplication sign at the start of units (where appropriate).

struct GwyUnit

struct GwyUnit;

struct GwyUnitClass

struct GwyUnitClass {
    GObjectClass parent_class;

    void (*value_changed)(GwyUnit *unit);
};

The “value-changed” signal

void
user_function (GwyUnit *gwysiunit,
               gpointer user_data)

The ::value-changed signal is emitted whenever unit changes.

Flags: Run First