Integer Operations

Integer Operations

Orientation Summary From Image

These scalar summaries are exposed through:

bundle_float_orientation

They operate on intensity images and use raw Sobel derivatives internally. Each example below shows the original image, Sobel x, Sobel y, and the scalar result.

Orientation Function Index

orientation_coherence
dominant_orientation
orientation_energy_0
orientation_energy_45
orientation_energy_90
orientation_energy_135
orientation_spread

Image To Float Region Statistics

These functions reduce a fixed local patch around a normalized image location to one Float64. They are exposed through:

bundle_number_regionFromImg

Coordinates are normalized in [0, 1]. For the first version:

region_mean, region_std, region_min, region_max, region_sum, region_median, region_range, region_energy, and region_entropy operate on a fixed 3 × 3 patch centered at (cx, cy).
region_contrast compares that 3 × 3 center patch to its surrounding 5 × 5 ring.
the same family is also available at fixed relative scales: *_5p, *_10p, and *_20p, where the patch side is derived from 5%, 10%, or 20% of min(height, width), clamped to an odd valid size.
windows are clipped at image borders, so corner evaluations use smaller valid patches rather than padding.

Region Function Index

region_mean
region_std
region_min
region_max
region_sum
region_median
region_range
region_contrast
region_energy
region_entropy
region_mean_5p
region_mean_10p
region_mean_20p
region_std_5p
region_std_10p
region_std_20p
region_min_5p
region_min_10p
region_min_20p
region_max_5p
region_max_10p
region_max_20p
region_sum_5p
region_sum_10p
region_sum_20p
region_median_5p
region_median_10p
region_median_20p
region_range_5p
region_range_10p
region_range_20p
region_contrast_5p
region_contrast_10p
region_contrast_20p
region_energy_5p
region_energy_10p
region_energy_20p
region_entropy_5p
region_entropy_10p
region_entropy_20p

`region_mean`

Mean over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_mean].fn
(
    fn(region_intensity, 0.4, 0.7),
    fn(region_binary, 0.4, 0.7),
    fn(region_segment, 0.4, 0.7),
)

Coordinates: (0.4, 0.7)

Result: (0.5660130718954248, 1.0, 2.0)

Intensity	Binary	Segment

`region_std`

Standard deviation over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_std].fn
(
    fn(region_intensity, 0.7, 0.3),
    fn(region_binary, 0.7, 0.3),
    fn(region_segment, 0.7, 0.3),
)

Coordinates: (0.7, 0.3)

Result: (0.020038836231053462, 0.5, 0.5)

Intensity	Binary	Segment

`region_min`

Minimum over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_min].fn
(
    fn(region_intensity, 0.1, 0.8),
    fn(region_binary, 0.1, 0.8),
    fn(region_segment, 0.1, 0.8),
)

Coordinates: (0.1, 0.8)

Result: (0.43137254901960786, 0.0, 4.0)

Intensity	Binary	Segment

`region_max`

Maximum over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_max].fn
(
    fn(region_intensity, 0.4, 0.4),
    fn(region_binary, 0.4, 0.4),
    fn(region_segment, 0.4, 0.4),
)

Coordinates: (0.4, 0.4)

Result: (0.9019607843137255, 1.0, 2.0)

Intensity	Binary	Segment

`region_sum`

Sum over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_sum].fn
(
    fn(region_intensity, 0.7, 0.0),
    fn(region_binary, 0.7, 0.0),
    fn(region_segment, 0.7, 0.0),
)

Coordinates: (0.7, 0.0)

Result: (2.2549019607843137, 0.0, 8.0)

Intensity	Binary	Segment

`region_median`

Median over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_median].fn
(
    fn(region_intensity, 0.1, 0.5),
    fn(region_binary, 0.1, 0.5),
    fn(region_segment, 0.1, 0.5),
)

Coordinates: (0.1, 0.5)

Result: (0.3333333333333333, 0.0, 1.0)

Intensity	Binary	Segment

`region_range`

Range over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_range].fn
(
    fn(region_intensity, 0.4, 0.1),
    fn(region_binary, 0.4, 0.1),
    fn(region_segment, 0.4, 0.1),
)

Coordinates: (0.4, 0.1)

Result: (0.06666666666666665, 1.0, 0.0)

Intensity	Binary	Segment

`region_contrast`

Mean(center 3x3) minus mean(surrounding 5x5 ring).

fn = UTCGP.bundle_number_regionFromImg[:region_contrast].fn
(
    fn(region_intensity, 0.7, 0.6),
    fn(region_binary, 0.7, 0.6),
    fn(region_segment, 0.7, 0.6),
)

Coordinates: (0.7, 0.6)

Result: (-5.551115123125783e-17, 0.10416666666666663, 0.10416666666666652)

Intensity	Binary	Segment

`region_energy`

Mean squared value over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_energy].fn
(
    fn(region_intensity, 0.1, 0.2),
    fn(region_binary, 0.1, 0.2),
    fn(region_segment, 0.1, 0.2),
)

Coordinates: (0.1, 0.2)

Result: (0.034168055021572906, 0.3333333333333333, 1.0)

Intensity	Binary	Segment

`region_entropy`

Cheap 8-bin entropy over a fixed 3x3 local patch.

fn = UTCGP.bundle_number_regionFromImg[:region_entropy].fn
(
    fn(region_intensity, 0.4, 0.7),
    fn(region_binary, 0.4, 0.7),
    fn(region_segment, 0.4, 0.7),
)

Coordinates: (0.4, 0.7)

Result: (2.197159723424149, 0.0, 0.0)

Intensity	Binary	Segment

`region_mean_5p`

Mean over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_mean_5p].fn
(
    fn(region_intensity, 0.7, 0.3),
    fn(region_binary, 0.7, 0.3),
    fn(region_segment, 0.7, 0.3),
)

Coordinates: (0.7, 0.3)

Result: (0.5172113289760348, 0.6666666666666666, 1.3333333333333333)

Intensity	Binary	Segment

`region_mean_10p`

Mean over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_mean_10p].fn
(
    fn(region_intensity, 0.1, 0.8),
    fn(region_binary, 0.1, 0.8),
    fn(region_segment, 0.1, 0.8),
)

Coordinates: (0.1, 0.8)

Result: (0.583442265795207, 0.0, 4.0)

Intensity	Binary	Segment

`region_mean_20p`

Mean over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_mean_20p].fn
(
    fn(region_intensity, 0.4, 0.4),
    fn(region_binary, 0.4, 0.4),
    fn(region_segment, 0.4, 0.4),
)

Coordinates: (0.4, 0.4)

Result: (0.689395758303321, 0.1836734693877551, 1.8571428571428572)

Intensity	Binary	Segment

`region_std_5p`

Standard deviation over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_std_5p].fn
(
    fn(region_intensity, 0.7, 0.0),
    fn(region_binary, 0.7, 0.0),
    fn(region_segment, 0.7, 0.0),
)

Coordinates: (0.7, 0.0)

Result: (0.017610710569029395, 0.0, 0.5163977794943223)

Intensity	Binary	Segment

`region_std_10p`

Standard deviation over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_std_10p].fn
(
    fn(region_intensity, 0.1, 0.5),
    fn(region_binary, 0.1, 0.5),
    fn(region_segment, 0.1, 0.5),
)

Coordinates: (0.1, 0.5)

Result: (0.02084342316222481, 0.0, 0.0)

Intensity	Binary	Segment

`region_std_20p`

Standard deviation over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_std_20p].fn
(
    fn(region_intensity, 0.4, 0.1),
    fn(region_binary, 0.4, 0.1),
    fn(region_segment, 0.4, 0.1),
)

Coordinates: (0.4, 0.1)

Result: (0.04755845543599683, 0.39123039821797606, 0.3535533905932735)

Intensity	Binary	Segment

`region_min_5p`

Minimum over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_min_5p].fn
(
    fn(region_intensity, 0.7, 0.6),
    fn(region_binary, 0.7, 0.6),
    fn(region_segment, 0.7, 0.6),
)

Coordinates: (0.7, 0.6)

Result: (0.2, 0.0, 2.0)

Intensity	Binary	Segment

`region_min_10p`

Minimum over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_min_10p].fn
(
    fn(region_intensity, 0.1, 0.2),
    fn(region_binary, 0.1, 0.2),
    fn(region_segment, 0.1, 0.2),
)

Coordinates: (0.1, 0.2)

Result: (0.14901960784313725, 0.0, 1.0)

Intensity	Binary	Segment

`region_min_20p`

Minimum over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_min_20p].fn
(
    fn(region_intensity, 0.4, 0.7),
    fn(region_binary, 0.4, 0.7),
    fn(region_segment, 0.4, 0.7),
)

Coordinates: (0.4, 0.7)

Result: (0.4666666666666667, 0.0, 1.0)

Intensity	Binary	Segment

`region_max_5p`

Maximum over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_max_5p].fn
(
    fn(region_intensity, 0.7, 0.3),
    fn(region_binary, 0.7, 0.3),
    fn(region_segment, 0.7, 0.3),
)

Coordinates: (0.7, 0.3)

Result: (0.5490196078431373, 1.0, 2.0)

Intensity	Binary	Segment

`region_max_10p`

Maximum over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_max_10p].fn
(
    fn(region_intensity, 0.1, 0.8),
    fn(region_binary, 0.1, 0.8),
    fn(region_segment, 0.1, 0.8),
)

Coordinates: (0.1, 0.8)

Result: (1.0, 0.0, 4.0)

Intensity	Binary	Segment

`region_max_20p`

Maximum over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_max_20p].fn
(
    fn(region_intensity, 0.4, 0.4),
    fn(region_binary, 0.4, 0.4),
    fn(region_segment, 0.4, 0.4),
)

Coordinates: (0.4, 0.4)

Result: (0.9019607843137255, 1.0, 2.0)

Intensity	Binary	Segment

`region_sum_5p`

Sum over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_sum_5p].fn
(
    fn(region_intensity, 0.7, 0.0),
    fn(region_binary, 0.7, 0.0),
    fn(region_segment, 0.7, 0.0),
)

Coordinates: (0.7, 0.0)

Result: (2.2549019607843137, 0.0, 8.0)

Intensity	Binary	Segment

`region_sum_10p`

Sum over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_sum_10p].fn
(
    fn(region_intensity, 0.1, 0.5),
    fn(region_binary, 0.1, 0.5),
    fn(region_segment, 0.1, 0.5),
)

Coordinates: (0.1, 0.5)

Result: (3.0, 0.0, 9.0)

Intensity	Binary	Segment

`region_sum_20p`

Sum over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_sum_20p].fn
(
    fn(region_intensity, 0.4, 0.1),
    fn(region_binary, 0.4, 0.1),
    fn(region_segment, 0.4, 0.1),
)

Coordinates: (0.4, 0.1)

Result: (13.88627450980393, 9.0, 91.0)

Intensity	Binary	Segment

`region_median_5p`

Median over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_median_5p].fn
(
    fn(region_intensity, 0.7, 0.6),
    fn(region_binary, 0.7, 0.6),
    fn(region_segment, 0.7, 0.6),
)

Coordinates: (0.7, 0.6)

Result: (0.2, 1.0, 3.0)

Intensity	Binary	Segment

`region_median_10p`

Median over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_median_10p].fn
(
    fn(region_intensity, 0.1, 0.2),
    fn(region_binary, 0.1, 0.2),
    fn(region_segment, 0.1, 0.2),
)

Coordinates: (0.1, 0.2)

Result: (0.1843137254901961, 0.0, 1.0)

Intensity	Binary	Segment

`region_median_20p`

Median over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_median_20p].fn
(
    fn(region_intensity, 0.4, 0.7),
    fn(region_binary, 0.4, 0.7),
    fn(region_segment, 0.4, 0.7),
)

Coordinates: (0.4, 0.7)

Result: (0.5843137254901961, 1.0, 2.0)

Intensity	Binary	Segment

`region_range_5p`

Range over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_range_5p].fn
(
    fn(region_intensity, 0.7, 0.3),
    fn(region_binary, 0.7, 0.3),
    fn(region_segment, 0.7, 0.3),
)

Coordinates: (0.7, 0.3)

Result: (0.06666666666666671, 1.0, 1.0)

Intensity	Binary	Segment

`region_range_10p`

Range over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_range_10p].fn
(
    fn(region_intensity, 0.1, 0.8),
    fn(region_binary, 0.1, 0.8),
    fn(region_segment, 0.1, 0.8),
)

Coordinates: (0.1, 0.8)

Result: (0.5686274509803921, 0.0, 0.0)

Intensity	Binary	Segment

`region_range_20p`

Range over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_range_20p].fn
(
    fn(region_intensity, 0.4, 0.4),
    fn(region_binary, 0.4, 0.4),
    fn(region_segment, 0.4, 0.4),
)

Coordinates: (0.4, 0.4)

Result: (0.48627450980392156, 1.0, 1.0)

Intensity	Binary	Segment

`region_contrast_5p`

Center-versus-ring contrast with a 5% local center scale.

fn = UTCGP.bundle_number_regionFromImg[:region_contrast_5p].fn
(
    fn(region_intensity, 0.7, 0.0),
    fn(region_binary, 0.7, 0.0),
    fn(region_segment, 0.7, 0.0),
)

Coordinates: (0.7, 0.0)

Result: (0.07403446226975635, 0.0, -0.12121212121212133)

Intensity	Binary	Segment

`region_contrast_10p`

Center-versus-ring contrast with a 10% local center scale.

fn = UTCGP.bundle_number_regionFromImg[:region_contrast_10p].fn
(
    fn(region_intensity, 0.1, 0.5),
    fn(region_binary, 0.1, 0.5),
    fn(region_segment, 0.1, 0.5),
)

Coordinates: (0.1, 0.5)

Result: (-5.551115123125783e-17, 0.0, 0.0)

Intensity	Binary	Segment

`region_contrast_20p`

Center-versus-ring contrast with a 20% local center scale.

fn = UTCGP.bundle_number_regionFromImg[:region_contrast_20p].fn
(
    fn(region_intensity, 0.4, 0.1),
    fn(region_binary, 0.4, 0.1),
    fn(region_segment, 0.4, 0.1),
)

Coordinates: (0.4, 0.1)

Result: (-0.12025775827572388, -0.16115411681914146, 0.270935960591133)

Intensity	Binary	Segment

`region_energy_5p`

Mean squared value over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_energy_5p].fn
(
    fn(region_intensity, 0.7, 0.6),
    fn(region_binary, 0.7, 0.6),
    fn(region_segment, 0.7, 0.6),
)

Coordinates: (0.7, 0.6)

Result: (0.04000000000000001, 0.6666666666666666, 7.333333333333333)

Intensity	Binary	Segment

`region_energy_10p`

Mean squared value over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_energy_10p].fn
(
    fn(region_intensity, 0.1, 0.2),
    fn(region_binary, 0.1, 0.2),
    fn(region_segment, 0.1, 0.2),
)

Coordinates: (0.1, 0.2)

Result: (0.034168055021572906, 0.3333333333333333, 1.0)

Intensity	Binary	Segment

`region_energy_20p`

Mean squared value over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_energy_20p].fn
(
    fn(region_intensity, 0.4, 0.7),
    fn(region_binary, 0.4, 0.7),
    fn(region_segment, 0.4, 0.7),
)

Coordinates: (0.4, 0.7)

Result: (0.3962604649703017, 0.5102040816326531, 5.1020408163265305)

Intensity	Binary	Segment

`region_entropy_5p`

Cheap 8-bin entropy over a local patch sized from 5% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_entropy_5p].fn
(
    fn(region_intensity, 0.7, 0.3),
    fn(region_binary, 0.7, 0.3),
    fn(region_segment, 0.7, 0.3),
)

Coordinates: (0.7, 0.3)

Result: (2.197159723424149, 0.9182958340544896, 0.9182958340544896)

Intensity	Binary	Segment

`region_entropy_10p`

Cheap 8-bin entropy over a local patch sized from 10% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_entropy_10p].fn
(
    fn(region_intensity, 0.1, 0.8),
    fn(region_binary, 0.1, 0.8),
    fn(region_segment, 0.1, 0.8),
)

Coordinates: (0.1, 0.8)

Result: (0.7642045065086203, 0.0, 0.0)

Intensity	Binary	Segment

`region_entropy_20p`

Cheap 8-bin entropy over a local patch sized from 20% of min(image side).

fn = UTCGP.bundle_number_regionFromImg[:region_entropy_20p].fn
(
    fn(region_intensity, 0.4, 0.4),
    fn(region_binary, 0.4, 0.4),
    fn(region_segment, 0.4, 0.4),
)

Coordinates: (0.4, 0.4)

Result: (1.4796352603999388, 0.6880476235340796, 0.5916727785823275)

Intensity	Binary	Segment

Haar Features From Image

These scalar Haar-like features are exposed through:

bundle_number_haarFromImg

position is a normalized column-major flattened position in [0, 1]. size is converted to a positive integer half-extent in pixels. The region is clipped to the image; no padding is used.

`haar_lr`

Left-versus-right rectangular contrast.

Current size convention in this implementation:

size = 1 means a clipped 3×3 local region
size = 2 means a clipped 5×5 local region
size = 3 means a clipped 7×7 local region

The intensity examples below keep the same center position and vary only the size. The binary example keeps size = 2 and moves the flattened position to 0.2 so the effect of the position parameter is visible too. The last binary example uses position = 0.0625, which maps to (row=4, col=1) in a 7x7 image under Julia's column-major flattening.

fn = UTCGP.bundle_number_haarFromImg[:haar_lr].fn
(
    intensity_size_1 = fn(haar_lr_intensity, 0.5, 1),
    intensity_size_2 = fn(haar_lr_intensity, 0.5, 2),
    intensity_size_3 = fn(haar_lr_intensity, 0.5, 3),
    binary_pos_02_size_2 = fn(haar_lr_binary, 0.2, 2),
    binary_row4_col1_size_2 = fn(haar_lr_binary, 0.0625, 2),
)

(intensity_size_1 = -0.6000000000000001, intensity_size_2 = -0.6509803921568627, intensity_size_3 = -0.7006535947712418, binary_pos_02_size_2 = 0.0, binary_row4_col1_size_2 = 0.0)

intensity size=1 orig

intensity size=1 overlay

intensity size=2 orig

intensity size=2 overlay

intensity size=3 orig

intensity size=3 overlay

binary pos=0.2 size=2 orig

haar_lr binary position 0.2 size 2 original

binary pos=0.2 size=2 overlay

haar_lr binary position 0.2 size 2 overlay

binary row=4 col=1 orig

binary row=4 col=1 overlay

`haar_tb`

Top-versus-bottom rectangular contrast.

fn = UTCGP.bundle_number_haarFromImg[:haar_tb].fn
(fn(haar_tb_intensity, 0.5, 2), fn(haar_tb_binary, 0.5, 2))

(1.0, 1.0)

intensity orig

intensity overlay

binary orig

binary overlay

`haar_diag_main`

Checkerboard contrast between the main-diagonal quadrants and the opposite quadrants.

fn = UTCGP.bundle_number_haarFromImg[:haar_diag_main].fn
(fn(haar_diag_main_intensity, 0.5, 2), fn(haar_diag_main_binary, 0.5, 2))

(0.75, 0.75)

intensity orig

intensity overlay

binary orig

binary overlay

`haar_diag_anti`

Checkerboard contrast between the anti-diagonal quadrants and the opposite quadrants.

fn = UTCGP.bundle_number_haarFromImg[:haar_diag_anti].fn
(fn(haar_diag_anti_intensity, 0.5, 2), fn(haar_diag_anti_binary, 0.5, 2))

(0.625, 0.625)

intensity orig

intensity overlay

binary orig

binary overlay

`haar_center_surround`

Center-versus-surround rectangular contrast.

fn = UTCGP.bundle_number_haarFromImg[:haar_center_surround].fn
(fn(haar_center_surround_intensity, 0.5, 2), fn(haar_center_surround_binary, 0.5, 2))

(0.7619047619047619, 0.7619047619047619)

intensity orig

intensity overlay

binary orig

binary overlay

`haar_three_h`

Three-rectangle horizontal contrast.

fn = UTCGP.bundle_number_haarFromImg[:haar_three_h].fn
(fn(haar_three_h_intensity, 0.5, 2), fn(haar_three_h_binary, 0.5, 2))

(0.5, 0.5)

intensity orig

intensity overlay

binary orig

binary overlay

`haar_three_v`

Three-rectangle vertical contrast.

fn = UTCGP.bundle_number_haarFromImg[:haar_three_v].fn
(fn(haar_three_v_intensity, 0.5, 2), fn(haar_three_v_binary, 0.5, 2))

(0.5, 0.5)

intensity orig

intensity overlay

binary orig

binary overlay

The default is int for the fallback. To cast to other types, use update_caster! and update_fallback! Exports :

bundle_number_arithmetic :
- number_sum
- number_minus
- number_mult
- number_div
- safe_div
- power_of

source

Functions

UTCGP.number_arithmetic.number_sum — Function

number_sum(a::Number, b::Number, args...)

Returns a+b

source

julia> number_sum(0,1)
1

UTCGP.number_arithmetic.number_minus — Function

number_minus(a::Number, b::Number, args...)

Returns a-b

source

julia> number_minus(0,1)
-1

UTCGP.number_arithmetic.number_mult — Function

number_mult(a::Number, b::Number, args...)

Returns a*b

source

julia> number_mult(3,3)
9

UTCGP.number_arithmetic.number_div — Function

number_div(a::Number, b::Number, args...)

Throws DivideError if the divisor is equal to 0.

Returns a/b

source

julia> number_div(3,3)
1.0

UTCGP.number_arithmetic.safe_div — Function

safe_div(a::Number, b::Number, args...)

If the divisor is equal (==) to 0, then the function returns 0 and does not raise an Error.

Else, the division works as expected.

source

julia> safe_div(3,0)
0

Reduce functions

Module

UTCGP.number_reduce — Module

REDUCE Functions : from vector of number to number

Exports :

bundle_number_reduce :
- reduce_sum
- reduce_min
- reduce_max
- reduce_argmin
- reduce_argmax
- reduce_length

source

Functions

UTCGP.number_reduce.reduce_sum — Function

reduce_sum(from :: Vector{<:Number}, args...)

Returns the sum of the vector

source

julia> reduce_sum([1,2,3])
6

UTCGP.number_reduce.reduce_min — Function

reduce_min(from::Vector{<:Number}, args...)

Returns the minimum in the vector.

source

julia> reduce_min([1,2,3])
1

UTCGP.number_reduce.reduce_max — Function

reduce_max(from::Vector{<:Number}, args...)

Returns the maximum in the vector.

source

julia> reduce_max([1,2,3])
3

UTCGP.number_reduce.reduce_argmin — Function

reduce_argmin(from::Vector{<:Number}, args...)

Returns the argmin of the vector.

source

julia> reduce_argmin([1,2,3])
1

UTCGP.number_reduce.reduce_argmax — Function

reduce_argmax(from::Vector{<:Number}, args...)

Returns the argmax of the vector.

source

julia> reduce_argmax([1,2,3])
3

UTCGP.number_reduce.reduce_length — Function

reduce_length(from::Vector{<:Any}, args...)

Returns the length of the vector

source

reduce_length(from::String, args...)

Return the length of the string.

source

julia> reduce_length(collect(1:10))
10