Add maximum() and minimum() for Vec

- Add _vec_max and _vec_min low-level PETSc wrappers using VecMax/VecMin
- Add Base.maximum(v::Vec) and Base.minimum(v::Vec) with docstrings
- Add test/test_minmax.jl with 5 test cases
- Update user guide and API reference with Reductions section
- Bump version to 0.1.18

Author: Sébastien Loisel

Project.toml

@@ -1,7 +1,7 @@
 name = "SafePETSc"
 uuid = "50acdc01-ce88-4ca7-bd87-6916c254362e"
 authors = ["Sébastien Loisel <S.Loisel@hw.ac.uk>"]
-version = "0.1.17"
+version = "0.1.18"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

docs/src/api/vectors.md

@@ -113,6 +113,28 @@ w = v' * A                             # Adjoint-vector times matrix
 LinearAlgebra.mul!(w, v', A)           # In-place
 ```
 
+### Reductions
+
+All reduction operations are **collective** - all ranks must call them.
+
+```@docs
+Base.sum(::SafePETSc.Vec)
+Base.maximum(::SafePETSc.Vec)
+Base.minimum(::SafePETSc.Vec)
+```
+
+#### Norms and Dot Products
+
+```julia
+# Vector norms
+n2 = norm(v)        # 2-norm (default)
+n1 = norm(v, 1)     # 1-norm
+ninf = norm(v, Inf) # Infinity norm
+
+# Dot product
+d = dot(v, w)       # Or: v' * w
+```
+
 ### Properties
 
 ```julia

docs/src/guide/vectors.md

@@ -99,6 +99,29 @@ x_adj = x'
 result = x' * A  # Returns adjoint vector
 ```
 
+### Reductions
+
+Compute scalar values from distributed vectors. All reduction operations are **collective** - all ranks must call them and receive the same result.
+
+```julia
+# Sum of all elements
+s = sum(v)
+
+# Maximum and minimum values
+max_val = maximum(v)
+min_val = minimum(v)
+
+# Norms
+n2 = norm(v)       # 2-norm (Euclidean), default
+n1 = norm(v, 1)    # 1-norm (sum of absolute values)
+ninf = norm(v, Inf) # Infinity norm (maximum absolute value)
+
+# Dot product
+d = dot(v, w)      # Or equivalently: v' * w
+```
+
+These operations use PETSc's efficient parallel implementations internally.
+
 ### Concatenation
 
 Vectors can be concatenated to form new vectors or matrices:

src/vec.jl

@@ -664,6 +664,46 @@ function Base.sum(v::Vec{T}) where {T}
     return result
 end
 
+"""
+    Base.maximum(v::Vec{T}) -> Real
+
+**MPI Collective**
+
+Compute the maximum element in a distributed PETSc vector.
+
+This is a collective operation - all ranks must call it and will receive the same result.
+Uses PETSc's VecMax function internally.
+
+# Example
+```julia
+v = Vec_uniform([1.0, 4.0, 2.0, 3.0])
+m = maximum(v)  # Returns 4.0 on all ranks
+```
+"""
+function Base.maximum(v::Vec{T}) where {T}
+    return _vec_max(v.obj.v)
+end
+
+"""
+    Base.minimum(v::Vec{T}) -> Real
+
+**MPI Collective**
+
+Compute the minimum element in a distributed PETSc vector.
+
+This is a collective operation - all ranks must call it and will receive the same result.
+Uses PETSc's VecMin function internally.
+
+# Example
+```julia
+v = Vec_uniform([1.0, 4.0, 2.0, 3.0])
+m = minimum(v)  # Returns 1.0 on all ranks
+```
+"""
+function Base.minimum(v::Vec{T}) where {T}
+    return _vec_min(v.obj.v)
+end
+
 # Norm of a vector: norm(v, p) (returns scalar)
 # Implements LinearAlgebra.norm to support standard Julia syntax
 """
@@ -789,6 +829,22 @@ PETSc.@for_libpetsc begin
                          v, PETSc.NORM_INFINITY, result)
         return result[]
     end
+
+    function _vec_max(v::PETSc.Vec{$PetscScalar})
+        result = Ref{$PetscReal}()
+        PETSc.@chk ccall((:VecMax, $libpetsc), PETSc.PetscErrorCode,
+                         (PETSc.CVec, Ptr{Cvoid}, Ptr{$PetscReal}),
+                         v, C_NULL, result)
+        return result[]
+    end
+
+    function _vec_min(v::PETSc.Vec{$PetscScalar})
+        result = Ref{$PetscReal}()
+        PETSc.@chk ccall((:VecMin, $libpetsc), PETSc.PetscErrorCode,
+                         (PETSc.CVec, Ptr{Cvoid}, Ptr{$PetscReal}),
+                         v, C_NULL, result)
+        return result[]
+    end
 end
 
 # In-place adjoint vector-matrix multiplication: w = v' * A (reuses pre-allocated w)

test/runtests.jl

@@ -108,6 +108,10 @@ end
         run_mpi_test(joinpath(@__DIR__, "test_vec_norm.jl"); nprocs=4, expect_success=true)
     end
 
+    @testset "Vec min/max Tests" begin
+        run_mpi_test(joinpath(@__DIR__, "test_minmax.jl"); nprocs=4, expect_success=true)
+    end
+
     @testset "Mat_uniform Tests" begin
         run_mpi_test(joinpath(@__DIR__, "test_mat_uniform.jl"); nprocs=4, expect_success=true)
     end

test/test_minmax.jl

@@ -0,0 +1,118 @@
+using Test
+using MPI
+using SafePETSc
+SafePETSc.Init()
+using PETSc
+using SafePETSc.SafeMPI
+include(joinpath(@__DIR__, "mpi_test_harness.jl"))
+using .MPITestHarness: QuietTestSet
+
+comm = MPI.COMM_WORLD
+rank = MPI.Comm_rank(comm)
+nranks = MPI.Comm_size(comm)
+
+if rank == 0
+    println("[DEBUG] Vec min/max test starting")
+    flush(stdout)
+end
+
+ts = @testset QuietTestSet "Vec min/max tests" begin
+
+if rank == 0
+    println("[DEBUG] Test 1: Basic maximum and minimum")
+    flush(stdout)
+end
+
+# Test 1: Basic maximum and minimum
+v = Vec_uniform([1.0, 4.0, 2.0, 3.0])
+@test sum(v) ≈ 10.0
+@test maximum(v) ≈ 4.0
+@test minimum(v) ≈ 1.0
+
+SafeMPI.check_and_destroy!()
+MPI.Barrier(comm)
+
+if rank == 0
+    println("[DEBUG] Test 2: Negative values")
+    flush(stdout)
+end
+
+# Test 2: Negative values
+v2 = Vec_uniform([-5.0, 2.0, -1.0, 3.0])
+@test maximum(v2) ≈ 3.0
+@test minimum(v2) ≈ -5.0
+
+SafeMPI.check_and_destroy!()
+MPI.Barrier(comm)
+
+if rank == 0
+    println("[DEBUG] Test 3: All same values")
+    flush(stdout)
+end
+
+# Test 3: All same values
+v3 = Vec_uniform([7.0, 7.0, 7.0, 7.0])
+@test maximum(v3) ≈ 7.0
+@test minimum(v3) ≈ 7.0
+
+SafeMPI.check_and_destroy!()
+MPI.Barrier(comm)
+
+if rank == 0
+    println("[DEBUG] Test 4: Single element")
+    flush(stdout)
+end
+
+# Test 4: Single element
+v4 = Vec_uniform([42.0])
+@test maximum(v4) ≈ 42.0
+@test minimum(v4) ≈ 42.0
+
+SafeMPI.check_and_destroy!()
+MPI.Barrier(comm)
+
+if rank == 0
+    println("[DEBUG] Test 5: Larger vector")
+    flush(stdout)
+end
+
+# Test 5: Larger vector distributed across ranks
+v5 = Vec_uniform(collect(1.0:16.0))
+@test maximum(v5) ≈ 16.0
+@test minimum(v5) ≈ 1.0
+@test sum(v5) ≈ 136.0  # 16*17/2
+
+SafeMPI.check_and_destroy!()
+MPI.Barrier(comm)
+
+end  # End of QuietTestSet
+
+# Aggregate per-rank counts and print a single summary on root
+local_counts = [
+    get(ts.counts, :pass, 0),
+    get(ts.counts, :fail, 0),
+    get(ts.counts, :error, 0),
+    get(ts.counts, :broken, 0),
+    get(ts.counts, :skip, 0),
+]
+
+global_counts = similar(local_counts)
+MPI.Allreduce!(local_counts, global_counts, +, comm)
+
+if rank == 0
+    println("Test Summary: Vec min/max tests (aggregated across $(nranks) ranks)")
+    println("  Pass: $(global_counts[1])  Fail: $(global_counts[2])  Error: $(global_counts[3])  Broken: $(global_counts[4])  Skip: $(global_counts[5])")
+end
+
+MPI.Barrier(comm)
+
+if global_counts[2] > 0 || global_counts[3] > 0
+    Base.exit(1)
+end
+
+MPI.Barrier(comm)
+
+if rank == 0
+    println("[DEBUG] Vec min/max test file completed successfully")
+    flush(stdout)
+end