17925485141

Committed 22 Sep 2025 06:56PM UTC coverage: 74.51% (+20.2%) from 54.286%

Build # 17925485141

Build Type

push

github

Committed by

web-flow

Commit Message

Minor CI fixes (#75)

* Re-add CI on master

* Rename workflows

* Use specific version of coveralls

* Update badges

* Add write permissions for coveralls action

* Permissions not actually needed

* Testing nightly only on ubuntu

Run Details

114 of 153 relevant lines covered (74.51%)

53.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.55

/src/IntelVectorMath.jl

__precompile__()

module IntelVectorMath

export IVM
const IVM = IntelVectorMath

# import Base: .^, ./
include("setup.jl")

function __init__()
    compilersupportlibaries_jll_uuid = Base.UUID("e66e0078-7015-5450-92f7-15fbd957f2ae")
    if Sys.isapple() && haskey(Base.loaded_modules, Base.PkgId(compilersupportlibaries_jll_uuid, "CompilerSupportLibraries_jll"))
        @warn "It appears CompilerSupportLibraries_jll was loaded prior to this package, which currently on mac may lead to wrong results in some cases. For further details see github.com/JuliaMath/IntelVectorMath.jl"
    end
end

include("function_list.jl")

## define functions from previous list for all eligible input types

for t in (Float32, Float64, ComplexF32, ComplexF64)
    # Unary, real or complex
    for (f, f!, f_mkl) in unary_real_complex
        def_unary_op(t, t, f, f!, f_mkl)
    end

    # # Binary, real or complex
    for (f, f!, f_mkl, broadcast) in binary_real_complex
        def_binary_op(t, t, f, f!, f_mkl, broadcast)
    end
end

for t in (Float32, Float64)
    # Unary, real only
    for (f, f!, f_mkl) in unary_real
        def_unary_op(t, t, f, f!, f_mkl)
    end

    for (f, f!, f_mkl, broadcast) in binary_real
        def_binary_op(t, t, f, f!, f_mkl, broadcast)
    end

    # Unary, complex-only
    for (f, f!, f_mkl) in unary_complex_inout
        def_unary_op(Complex{t}, Complex{t}, f, f!, f_mkl)
    end
    for (f, f!, f_mkl) in unary_complex_in
        def_unary_op(Complex{t}, t, f, f!, f_mkl)
    end

    ### cis is special, IntelVectorMath function is based on output
    def_unary_op(t, Complex{t}, :cis, :cis!, :CIS; vmltype=Complex{t})

    def_one2two_op(t, t, :sincos, :sincos!, :SinCos)

    # Binary, complex-only. These are more accurate but performance is
    # either equivalent to Base or slower.
    # def_binary_op(Complex{t}, Complex{t}, (:+), :add!, :Add, false)
    # def_binary_op(Complex{t}, Complex{t}, (:.+), :add!, :Add, true)
    # def_binary_op(Complex{t}, Complex{t}, (:.*), :multiply!, :Mul, true)
    # def_binary_op(Complex{t}, Complex{t}, (:-), :subtract!, :Sub, false)
    # def_binary_op(Complex{t}, Complex{t}, (:.-), :subtract!, :Sub, true)
    # def_binary_op(Complex{t}, Complex{t}, :multiply_conj, :multiply_conj!, :Mul, false)

    # # .^ to scalar power
    # mklfn = Base.Meta.quot(Symbol("$(vml_prefix(t))Powx"))
    # @eval begin
    #     export pow!
    #     function pow!{N}(out::Array{$t,N}, A::Array{$t,N}, b::$t)
    #         size(out) == size(A) || throw(DimensionMismatch())
    #         ccall(($mklfn, lib), Nothing, (Int, Ptr{$t}, $t, Ptr{$t}), length(A), A, b, out)
    #         vml_check_error()
    #         out
    #     end
    #     function (.^){N}(A::Array{$t,N}, b::$t)
    #         out = similar(A)
    #         ccall(($mklfn, lib), Nothing, (Int, Ptr{$t}, $t, Ptr{$t}), length(A), A, b, out)
    #         vml_check_error()
    #         out
    #     end
    # end
end

export VML_LA, VML_HA, VML_EP, vml_set_accuracy, vml_get_accuracy
export VML_DENORMAL_FAST, VML_DENORMAL_ACCURATE, vml_set_denormalmode, vml_get_denormalmode
export vml_get_max_threads, vml_set_num_threads
export vml_get_cpu_frequency, vml_get_max_cpu_frequency

# do not export, seems to be no-op in 2022
# export VML_FPU_DEFAULT, VML_FPU_FLOAT32, VML_FPU_FLOAT64, VML_FPU_RESTORE, vml_set_fpumode, vml_get_fpumode


end

1	__precompile__()
2
3	module IntelVectorMath	2✔
4
5	export IVM
6	const IVM = IntelVectorMath
7
8	# import Base: .^, ./
9	include("setup.jl")
10
11	function __init__()	1✔
12	compilersupportlibaries_jll_uuid = Base.UUID("e66e0078-7015-5450-92f7-15fbd957f2ae")	1✔
13	if Sys.isapple() && haskey(Base.loaded_modules, Base.PkgId(compilersupportlibaries_jll_uuid, "CompilerSupportLibraries_jll"))	1✔
14	@warn "It appears CompilerSupportLibraries_jll was loaded prior to this package, which currently on mac may lead to wrong results in some cases. For further details see github.com/JuliaMath/IntelVectorMath.jl"	×
15	end
16	end
17
18	include("function_list.jl")
19
20	## define functions from previous list for all eligible input types
21
22	for t in (Float32, Float64, ComplexF32, ComplexF64)	1✔
23	# Unary, real or complex
24	for (f, f!, f_mkl) in unary_real_complex	4✔
25	def_unary_op(t, t, f, f!, f_mkl)	28✔
26	end	28✔
27
28	# # Binary, real or complex
29	for (f, f!, f_mkl, broadcast) in binary_real_complex	4✔
30	def_binary_op(t, t, f, f!, f_mkl, broadcast)	8✔
31	end	8✔
32	end	4✔
33
34	for t in (Float32, Float64)	1✔
35	# Unary, real only
36	for (f, f!, f_mkl) in unary_real	2✔
37	def_unary_op(t, t, f, f!, f_mkl)	78✔
38	end	78✔
39
40	for (f, f!, f_mkl, broadcast) in binary_real	2✔
41	def_binary_op(t, t, f, f!, f_mkl, broadcast)	6✔
42	end	6✔
43
44	# Unary, complex-only
45	for (f, f!, f_mkl) in unary_complex_inout	2✔
46	def_unary_op(Complex{t}, Complex{t}, f, f!, f_mkl)	2✔
47	end	2✔
48	for (f, f!, f_mkl) in unary_complex_in	2✔
49	def_unary_op(Complex{t}, t, f, f!, f_mkl)	4✔
50	end	4✔
51
52	### cis is special, IntelVectorMath function is based on output
53	def_unary_op(t, Complex{t}, :cis, :cis!, :CIS; vmltype=Complex{t})	2✔
54
55	def_one2two_op(t, t, :sincos, :sincos!, :SinCos)	2✔
56
57	# Binary, complex-only. These are more accurate but performance is
58	# either equivalent to Base or slower.
59	# def_binary_op(Complex{t}, Complex{t}, (:+), :add!, :Add, false)
60	# def_binary_op(Complex{t}, Complex{t}, (:.+), :add!, :Add, true)
61	# def_binary_op(Complex{t}, Complex{t}, (:.*), :multiply!, :Mul, true)
62	# def_binary_op(Complex{t}, Complex{t}, (:-), :subtract!, :Sub, false)
63	# def_binary_op(Complex{t}, Complex{t}, (:.-), :subtract!, :Sub, true)
64	# def_binary_op(Complex{t}, Complex{t}, :multiply_conj, :multiply_conj!, :Mul, false)
65
66	# # .^ to scalar power
67	# mklfn = Base.Meta.quot(Symbol("$(vml_prefix(t))Powx"))
68	# @eval begin
69	# export pow!
70	# function pow!{N}(out::Array{$t,N}, A::Array{$t,N}, b::$t)
71	# size(out) == size(A) \|\| throw(DimensionMismatch())
72	# ccall(($mklfn, lib), Nothing, (Int, Ptr{$t}, $t, Ptr{$t}), length(A), A, b, out)
73	# vml_check_error()
74	# out
75	# end
76	# function (.^){N}(A::Array{$t,N}, b::$t)
77	# out = similar(A)
78	# ccall(($mklfn, lib), Nothing, (Int, Ptr{$t}, $t, Ptr{$t}), length(A), A, b, out)
79	# vml_check_error()
80	# out
81	# end
82	# end
83	end	2✔
84
85	export VML_LA, VML_HA, VML_EP, vml_set_accuracy, vml_get_accuracy
86	export VML_DENORMAL_FAST, VML_DENORMAL_ACCURATE, vml_set_denormalmode, vml_get_denormalmode
87	export vml_get_max_threads, vml_set_num_threads
88	export vml_get_cpu_frequency, vml_get_max_cpu_frequency
89
90	# do not export, seems to be no-op in 2022
91	# export VML_FPU_DEFAULT, VML_FPU_FLOAT32, VML_FPU_FLOAT64, VML_FPU_RESTORE, vml_set_fpumode, vml_get_fpumode
92
93
94	end

JuliaMath / IntelVectorMath.jl / 17925485141

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous