revert

Author: klamike

src/nlp/batch/foreach.jl

@@ -122,12 +122,12 @@ batch_cons_nln(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(cons_nln, bnlp, xs)
 batch_jac(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(jac, bnlp, xs)
-batch_jac_lin(bnlp::ForEachBatchNLPModel) =
-  _batch_map(jac_lin, bnlp)
+batch_jac_lin(bnlp::ForEachBatchNLPModel, xs) =
+  _batch_map(jac_lin, bnlp, xs)
 batch_jac_nln(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(jac_nln, bnlp, xs)
-batch_jac_lin_coord(bnlp::ForEachBatchNLPModel) =
-  _batch_map(jac_lin_coord, bnlp)
+batch_jac_lin_coord(bnlp::ForEachBatchNLPModel, xs) =
+  _batch_map(jac_lin_coord, bnlp, xs)
 batch_jac_coord(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(jac_coord, bnlp, xs)
 batch_jac_nln_coord(bnlp::ForEachBatchNLPModel, xs) =
@@ -146,10 +146,10 @@ batch_jprod_nln(bnlp::ForEachBatchNLPModel, xs, vs) =
   _batch_map(jprod_nln, bnlp, xs, vs)
 batch_jtprod_nln(bnlp::ForEachBatchNLPModel, xs, vs) =
   _batch_map(jtprod_nln, bnlp, xs, vs)
-batch_jprod_lin(bnlp::ForEachBatchNLPModel, vs) =
-  _batch_map(jprod_lin, bnlp, vs)
-batch_jtprod_lin(bnlp::ForEachBatchNLPModel, vs) =
-  _batch_map(jtprod_lin, bnlp, vs)
+batch_jprod_lin(bnlp::ForEachBatchNLPModel, xs, vs) =
+  _batch_map(jprod_lin, bnlp, xs, vs)
+batch_jtprod_lin(bnlp::ForEachBatchNLPModel, xs, vs) =
+  _batch_map(jtprod_lin, bnlp, xs, vs)
 batch_ghjvprod(bnlp::ForEachBatchNLPModel, xs, gs, vs) =
   _batch_map(ghjvprod, bnlp, xs, gs, vs)
 
@@ -161,8 +161,8 @@ batch_jac_nln_structure!(bnlp::ForEachBatchNLPModel, rowss, colss) =
   _batch_map!(jac_nln_structure!, bnlp, rowss, colss)
 batch_hess_structure!(bnlp::ForEachBatchNLPModel, rowss, colss) =
   _batch_map!(hess_structure!, bnlp, rowss, colss)
-batch_jac_lin_coord!(bnlp::ForEachBatchNLPModel, valss) =
-  _batch_map!(jac_lin_coord!, bnlp, valss)
+batch_jac_lin_coord!(bnlp::ForEachBatchNLPModel, xs, valss) =
+  _batch_map!(jac_lin_coord!, bnlp, xs, valss)
 batch_grad!(bnlp::ForEachBatchNLPModel, xs, gs) =
   _batch_map!(grad!, bnlp, xs, gs)
 batch_cons!(bnlp::ForEachBatchNLPModel, xs, cs) =
@@ -183,10 +183,10 @@ batch_jprod_nln!(bnlp::ForEachBatchNLPModel, xs, vs, Jvs) =
   _batch_map!(jprod_nln!, bnlp, xs, vs, Jvs)
 batch_jtprod_nln!(bnlp::ForEachBatchNLPModel, xs, vs, Jtvs) =
   _batch_map!(jtprod_nln!, bnlp, xs, vs, Jtvs)
-batch_jprod_lin!(bnlp::ForEachBatchNLPModel, vs, Jvs) =
-  _batch_map!(jprod_lin!, bnlp, vs, Jvs)
-batch_jtprod_lin!(bnlp::ForEachBatchNLPModel, vs, Jtvs) =
-  _batch_map!(jtprod_lin!, bnlp, vs, Jtvs)
+batch_jprod_lin!(bnlp::ForEachBatchNLPModel, xs, vs, Jvs) =
+  _batch_map!(jprod_lin!, bnlp, xs, vs, Jvs)
+batch_jtprod_lin!(bnlp::ForEachBatchNLPModel, xs, vs, Jtvs) =
+  _batch_map!(jtprod_lin!, bnlp, xs, vs, Jtvs)
 batch_ghjvprod!(bnlp::ForEachBatchNLPModel, xs, gs, vs, gHvs) =
   _batch_map!(ghjvprod!, bnlp, xs, gs, vs, gHvs)
 
@@ -246,15 +246,15 @@ batch_hess(bnlp::ForEachBatchNLPModel, xs, ys; obj_weights) =
 ## operators
 batch_jac_op(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(jac_op, bnlp, xs)
-batch_jac_lin_op(bnlp::ForEachBatchNLPModel) =
-  _batch_map(jac_lin_op, bnlp)
+batch_jac_lin_op(bnlp::ForEachBatchNLPModel, xs) =
+  _batch_map(jac_lin_op, bnlp, xs)
 batch_jac_nln_op(bnlp::ForEachBatchNLPModel, xs) =
   _batch_map(jac_nln_op, bnlp, xs)
 
 batch_jac_op!(bnlp::ForEachBatchNLPModel, xs, Jvs, Jtvs) =
   _batch_map(jac_op!, bnlp, xs, Jvs, Jtvs)
-batch_jac_lin_op!(bnlp::ForEachBatchNLPModel, Jvs, Jtvs) =
-  _batch_map(jac_lin_op!, bnlp, Jvs, Jtvs)
+batch_jac_lin_op!(bnlp::ForEachBatchNLPModel, xs, Jvs, Jtvs) =
+  _batch_map(jac_lin_op!, bnlp, xs, Jvs, Jtvs)
 batch_jac_nln_op!(bnlp::ForEachBatchNLPModel, xs, Jvs, Jtvs) =
   _batch_map(jac_nln_op!, bnlp, xs, Jvs, Jtvs)
 

src/nlp/batch/inplace.jl

@@ -132,12 +132,12 @@ batch_cons_nln(bnlp::InplaceBatchNLPModel, xs) =
   _batch_map(cons_nln, bnlp, xs)
 batch_jac(bnlp::InplaceBatchNLPModel, xs) =
   _batch_map(jac, bnlp, xs)
-batch_jac_lin(bnlp::InplaceBatchNLPModel) =
-  _batch_map(jac_lin, bnlp)
+batch_jac_lin(bnlp::InplaceBatchNLPModel, xs) =
+  _batch_map(jac_lin, bnlp, xs)
 batch_jac_nln(bnlp::InplaceBatchNLPModel, xs) =
   _batch_map(jac_nln, bnlp, xs)
-batch_jac_lin_coord(bnlp::InplaceBatchNLPModel) =
-  _batch_map(jac_lin_coord, bnlp)
+batch_jac_lin_coord(bnlp::InplaceBatchNLPModel, xs) =
+  _batch_map(jac_lin_coord, bnlp, xs)
 batch_jac_coord(bnlp::InplaceBatchNLPModel, xs) =
   _batch_map(jac_coord, bnlp, xs)
 batch_jac_nln_coord(bnlp::InplaceBatchNLPModel, xs) =
@@ -156,10 +156,10 @@ batch_jprod_nln(bnlp::InplaceBatchNLPModel, xs, vs) =
   _batch_map(jprod_nln, bnlp, xs, vs)
 batch_jtprod_nln(bnlp::InplaceBatchNLPModel, xs, vs) =
   _batch_map(jtprod_nln, bnlp, xs, vs)
-batch_jprod_lin(bnlp::InplaceBatchNLPModel, vs) =
-  _batch_map(jprod_lin, bnlp, vs)
-batch_jtprod_lin(bnlp::InplaceBatchNLPModel, vs) =
-  _batch_map(jtprod_lin, bnlp, vs)
+batch_jprod_lin(bnlp::InplaceBatchNLPModel, xs, vs) =
+  _batch_map(jprod_lin, bnlp, xs, vs)
+batch_jtprod_lin(bnlp::InplaceBatchNLPModel, xs, vs) =
+  _batch_map(jtprod_lin, bnlp, xs, vs)
 batch_ghjvprod(bnlp::InplaceBatchNLPModel, xs, gs, vs) =
   _batch_map(ghjvprod, bnlp, xs, gs, vs)
 
@@ -171,8 +171,8 @@ batch_jac_nln_structure!(bnlp::InplaceBatchNLPModel, rowss, colss) =
   _batch_map!(jac_nln_structure!, bnlp, rowss, colss)
 batch_hess_structure!(bnlp::InplaceBatchNLPModel, rowss, colss) =
   _batch_map!(hess_structure!, bnlp, rowss, colss)
-batch_jac_lin_coord!(bnlp::InplaceBatchNLPModel, valss) =
-  _batch_map!(jac_lin_coord!, bnlp, valss)
+batch_jac_lin_coord!(bnlp::InplaceBatchNLPModel, xs, valss) =
+  _batch_map!(jac_lin_coord!, bnlp, xs, valss)
 batch_grad!(bnlp::InplaceBatchNLPModel, xs, gs) =
   _batch_map!(grad!, bnlp, xs, gs)
 batch_cons!(bnlp::InplaceBatchNLPModel, xs, cs) =
@@ -193,10 +193,10 @@ batch_jprod_nln!(bnlp::InplaceBatchNLPModel, xs, vs, Jvs) =
   _batch_map!(jprod_nln!, bnlp, xs, vs, Jvs)
 batch_jtprod_nln!(bnlp::InplaceBatchNLPModel, xs, vs, Jtvs) =
   _batch_map!(jtprod_nln!, bnlp, xs, vs, Jtvs)
-batch_jprod_lin!(bnlp::InplaceBatchNLPModel, vs, Jvs) =
-  _batch_map!(jprod_lin!, bnlp, vs, Jvs)
-batch_jtprod_lin!(bnlp::InplaceBatchNLPModel, vs, Jtvs) =
-  _batch_map!(jtprod_lin!, bnlp, vs, Jtvs)
+batch_jprod_lin!(bnlp::InplaceBatchNLPModel, xs, vs, Jvs) =
+  _batch_map!(jprod_lin!, bnlp, xs, vs, Jvs)
+batch_jtprod_lin!(bnlp::InplaceBatchNLPModel, xs, vs, Jtvs) =
+  _batch_map!(jtprod_lin!, bnlp, xs, vs, Jtvs)
 batch_ghjvprod!(bnlp::InplaceBatchNLPModel, xs, gs, vs, gHvs) =
   _batch_map!(ghjvprod!, bnlp, xs, gs, vs, gHvs)
 
@@ -251,11 +251,11 @@ batch_hess(bnlp::InplaceBatchNLPModel, xs, ys; obj_weights) =
 
 ## operators
 batch_jac_op(bnlp::InplaceBatchNLPModel, xs) = _inplace_operator_error()
-batch_jac_lin_op(bnlp::InplaceBatchNLPModel) = _inplace_operator_error()
+batch_jac_lin_op(bnlp::InplaceBatchNLPModel, xs) = _inplace_operator_error()
 batch_jac_nln_op(bnlp::InplaceBatchNLPModel, xs) = _inplace_operator_error()
 
 batch_jac_op!(bnlp::InplaceBatchNLPModel, xs, Jvs, Jtvs) = _inplace_operator_error()
-batch_jac_lin_op!(bnlp::InplaceBatchNLPModel, Jvs, Jtvs) = _inplace_operator_error()
+batch_jac_lin_op!(bnlp::InplaceBatchNLPModel, xs, Jvs, Jtvs) = _inplace_operator_error()
 batch_jac_nln_op!(bnlp::InplaceBatchNLPModel, xs, Jvs, Jtvs) = _inplace_operator_error()
 
 ## tuple functions

test/nlp/batch_api.jl

@@ -127,20 +127,20 @@
       @test jac_coords ≈ manual_jac_coords
 
       # Test batch_jac_lin
-      batch_jac_lins = batch_jac_lin(bnlp)
-      manual_jac_lins = [jac_lin(models[i]) for i = 1:n_models]
+      batch_jac_lins = batch_jac_lin(bnlp, xs)
+      manual_jac_lins = [jac_lin(models[i], xs[i]) for i = 1:n_models]
       @test batch_jac_lins ≈ manual_jac_lins
 
       # Test batch_jac_lin_coord
-      batch_jac_lin_coords = batch_jac_lin_coord(bnlp)
-      manual_jac_lin_coords = [jac_lin_coord(models[i]) for i = 1:n_models]
+      batch_jac_lin_coords = batch_jac_lin_coord(bnlp, xs)
+      manual_jac_lin_coords = [jac_lin_coord(models[i], xs[i]) for i = 1:n_models]
       @test batch_jac_lin_coords ≈ manual_jac_lin_coords
 
       # Test batch_jac_lin_coord!
       jac_lin_coords = [zeros(meta.lin_nnzj) for _ = 1:n_models]
-      batch_jac_lin_coord!(bnlp, jac_lin_coords)
+      batch_jac_lin_coord!(bnlp, xs, jac_lin_coords)
       manual_jac_lin_coords =
-        [jac_lin_coord!(models[i], zeros(meta.lin_nnzj)) for i = 1:n_models]
+        [jac_lin_coord!(models[i], xs[i], zeros(meta.lin_nnzj)) for i = 1:n_models]
       @test jac_lin_coords ≈ manual_jac_lin_coords
 
       # Test batch_jac_nln
@@ -183,26 +183,26 @@
       @test jtprods ≈ manual_jtprods
 
       # Test batch_jprod_lin
-      batch_jprod_lins = batch_jprod_lin(bnlp, vs)
-      manual_jprod_lins = [jprod_lin(models[i], vs[i]) for i = 1:n_models]
+      batch_jprod_lins = batch_jprod_lin(bnlp, xs, vs)
+      manual_jprod_lins = [jprod_lin(models[i], xs[i], vs[i]) for i = 1:n_models]
       @test batch_jprod_lins ≈ manual_jprod_lins
 
       # Test batch_jprod_lin!
       jprod_lins = [zeros(meta.nlin) for _ = 1:n_models]
-      batch_jprod_lin!(bnlp, vs, jprod_lins)
-      manual_jprod_lins = [jprod_lin!(models[i], vs[i], zeros(meta.nlin)) for i = 1:n_models]
+      batch_jprod_lin!(bnlp, xs, vs, jprod_lins)
+      manual_jprod_lins = [jprod_lin!(models[i], xs[i], vs[i], zeros(meta.nlin)) for i = 1:n_models]
       @test jprod_lins ≈ manual_jprod_lins
 
       # Test batch_jtprod_lin
       ws_lin = [ws[i][1:(meta.nlin)] for i = 1:n_models]
-      batch_jtprod_lins = batch_jtprod_lin(bnlp, ws_lin)
-      manual_jtprod_lins = [jtprod_lin(models[i], ws_lin[i]) for i = 1:n_models]
+      batch_jtprod_lins = batch_jtprod_lin(bnlp, xs, ws_lin)
+      manual_jtprod_lins = [jtprod_lin(models[i], xs[i], ws_lin[i]) for i = 1:n_models]
       @test batch_jtprod_lins ≈ manual_jtprod_lins
 
       # Test batch_jtprod_lin!
       jtprod_lins = [zeros(n) for _ = 1:n_models]
-      batch_jtprod_lin!(bnlp, ws_lin, jtprod_lins)
-      manual_jtprod_lins = [jtprod_lin!(models[i], ws_lin[i], zeros(n)) for i = 1:n_models]
+      batch_jtprod_lin!(bnlp, xs, ws_lin, jtprod_lins)
+      manual_jtprod_lins = [jtprod_lin!(models[i], xs[i], ws_lin[i], zeros(n)) for i = 1:n_models]
       @test jtprod_lins ≈ manual_jtprod_lins
 
       # Test batch_jprod_nln
@@ -432,8 +432,8 @@
         end
 
         # Test batch_jac_lin_op
-        batch_jac_lin_ops = batch_jac_lin_op(bnlp)
-        manual_jac_lin_ops = [jac_lin_op(models[i]) for i = 1:n_models]
+        batch_jac_lin_ops = batch_jac_lin_op(bnlp, xs)
+        manual_jac_lin_ops = [jac_lin_op(models[i], xs[i]) for i = 1:n_models]
         ws_lin_vec = ws[1][1:(meta.nlin)]
         for i = 1:n_models
           @test batch_jac_lin_ops[i] * vs[i] ≈ manual_jac_lin_ops[i] * vs[i]
@@ -443,9 +443,9 @@
         # Test batch_jac_lin_op!
         jvs_lin = [zeros(meta.nlin) for _ = 1:n_models]
         jtvs_lin = [zeros(n) for _ = 1:n_models]
-        batch_jac_lin_ops = batch_jac_lin_op!(bnlp, jvs_lin, jtvs_lin)
+        batch_jac_lin_ops = batch_jac_lin_op!(bnlp, xs, jvs_lin, jtvs_lin)
         manual_jac_lin_ops =
-          [jac_lin_op!(models[i], zeros(meta.nlin), zeros(n)) for i = 1:n_models]
+          [jac_lin_op!(models[i], xs[i], zeros(meta.nlin), zeros(n)) for i = 1:n_models]
         for i = 1:n_models
           @test batch_jac_lin_ops[i] * vs[i] ≈ manual_jac_lin_ops[i] * vs[i]
           @test batch_jac_lin_ops[i]' * ws_lin_vec ≈ manual_jac_lin_ops[i]' * ws_lin_vec
@@ -474,8 +474,8 @@
         @test_throws ErrorException batch_jac_op(bnlp, xs)
         @test_throws ErrorException batch_jac_op!(bnlp, xs, [zeros(m) for _ = 1:n_models],
                                                   [zeros(n) for _ = 1:n_models])
-        @test_throws ErrorException batch_jac_lin_op(bnlp)
-        @test_throws ErrorException batch_jac_lin_op!(bnlp,
+        @test_throws ErrorException batch_jac_lin_op(bnlp, xs)
+        @test_throws ErrorException batch_jac_lin_op!(bnlp, xs,
                                                       [zeros(meta.nlin) for _ = 1:n_models],
                                                       [zeros(n) for _ = 1:n_models])
         @test_throws ErrorException batch_jac_nln_op(bnlp, xs)