[vspline] 43/72: mainly documentation work
Kay F. Jahnke
kfj-guest at moszumanska.debian.org
Sun Jul 2 09:02:41 UTC 2017
This is an automated email from the git hooks/post-receive script.
kfj-guest pushed a commit to branch master
in repository vspline.
commit ba9cbac734980a02bf8ec17245f5924866aaedc2
Author: Kay F. Jahnke <kfjahnke at gmail.com>
Date: Sun Apr 16 10:22:23 2017 +0200
mainly documentation work
---
basis.h | 10 ++++-
brace.h | 10 ++++-
bspline.h | 28 ++++++++++----
common.h | 10 ++++-
coordinate.h | 10 ++++-
doxy.h | 12 +++++-
eval.h | 27 ++++++++-----
filter.h | 10 ++++-
mapping.h | 10 ++++-
multithread.h | 115 +++++++++++++++++++++++++++++++++-----------------------
poles.h | 8 ++++
prefilter.h | 10 ++++-
remap.h | 14 ++++++-
thread_pool.h | 10 ++++-
unary_functor.h | 10 ++++-
vspline.h | 10 ++++-
16 files changed, 227 insertions(+), 77 deletions(-)
diff --git a/basis.h b/basis.h
index 4927629..b1c84df 100644
--- a/basis.h
+++ b/basis.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/brace.h b/brace.h
index 27d5d18..f6997cd 100644
--- a/brace.h
+++ b/brace.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/bspline.h b/bspline.h
index 4c3fc72..9e3f8ba 100644
--- a/bspline.h
+++ b/bspline.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
@@ -324,8 +332,8 @@ public:
// TODO: write copy constructor, operator=
- bspline ( shape_type _core_shape , ///< shape of knot point data
- int _spline_degree = 3 , ///< spline degree with reasonable default
+ bspline ( shape_type _core_shape , ///< shape of knot point data
+ int _spline_degree = 3 , ///< spline degree with reasonable default
bcv_type _bcv = bcv_type ( MIRROR ) , ///< boundary conditions and common default
prefilter_strategy _strategy = BRACED , ///< default strategy is the 'implicit' scheme
int _horizon = -1 , ///< width of frame for explicit scheme
@@ -478,10 +486,12 @@ public:
/// If data are passed in, they have to have precisely the shape
/// we have set up in core (_core_shape passed into the constructor).
/// These data will then be used in place of any data present in the
- /// bspline object.
+ /// bspline object to calculate the coefficients. They won't be looked at
+ /// after prefilter() terminates, so it's safe to pass in some MultiArrayView
+ /// which is destroyed after the call to prefilter().
- void prefilter ( bool use_vc = true , ///< use Vc by default
- int njobs = default_njobs , ///< intended number of jobs to use
+ void prefilter ( bool use_vc = true , ///< use Vc by default
+ int njobs = default_njobs , ///< intended number of jobs to use
view_type data = view_type() ) ///< view to knot point data to use instead of 'core'
{
// if the user should have modified 'bcv' since the bspline object's creation,
@@ -567,8 +577,8 @@ public:
// br ( coeffs , bcv[d] , spline_degree , d ) ;
break ;
case EXPLICIT:
- // apply bracing with BC codes passed in, then solve with BC code GUESS
- // this automatically fills the brace, as well, since it's part of the frame.
+ // first apply bracing with BC codes passed in, then solve with BC code GUESS
+ // this automatically fills the brace as well, since it's part of the frame.
// TODO: the values in the frame will not come out precisely the same as they
// would by filling the brace after the coefficients have been calculated.
// The difference will be larger towards the margin of the frame, and we assume
@@ -661,6 +671,8 @@ public:
/// But if bcv is changed to another mapping mode, the shift might not work out,
/// the point in case being REFLECT bondary conditions with their widened brace
/// for odd spline degrees.
+
+ // TODO consider moving the concept of shifting to class evaluator
int shift ( int d )
{
diff --git a/common.h b/common.h
index 3227503..591bf2c 100644
--- a/common.h
+++ b/common.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/coordinate.h b/coordinate.h
index dcb24aa..a39d3cb 100644
--- a/coordinate.h
+++ b/coordinate.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/doxy.h b/doxy.h
index 4bee643..abb5c9a 100644
--- a/doxy.h
+++ b/doxy.h
@@ -1,9 +1,17 @@
/************************************************************************/
/* */
/* vspline - a set of generic tools for creation and evaluation */
-/* of uniform b-splines */
+/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/eval.h b/eval.h
index c7be940..51f196b 100644
--- a/eval.h
+++ b/eval.h
@@ -5,6 +5,14 @@
/* */
/* Copyright 2015 - 2017 by Kay F. Jahnke */
/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
+/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
/* files (the "Software"), to deal in the Software without */
@@ -348,10 +356,7 @@ struct average_weight_functor
*/
-/// class evaluator encodes evaluation of a B-spline. This is coded so that the spline's dimension,
-/// and data type are template arguments, while it's order is a run time argument. While the typedefs
-/// are many and look difficult, they are mainly used to use concise type names in the actual
-/// calculation routines, which are by contrast simple.
+/// class evaluator encodes evaluation of a B-spline.
/// I have already hinted at the process used, but here it is again in a nutshell:
/// The coordinate at which the spline is to be evaluated is split into it's integral part
/// and a remaining fraction. The integral part defines the location where a window from the
@@ -386,8 +391,8 @@ struct average_weight_functor
/// steps can be bound into a single functor, and the calling code can be reduced to polling
/// this functor until it has obtained the desired number of output values.
/// While the 'unspecialized' evaluator will try and do 'the right thing' by using general
-/// purpose code fit for all eventualities, for time-critical operation there are two specializations
-/// which can be used to make the code faster:
+/// purpose code fit for all eventualities, for time-critical operation there are two
+/// specializations which can be used to make the code faster:
///
/// - template argument 'specialize' can be set to 0 to forcibly use (more efficient) nearest
/// neighbour interpolation, which has the same effect as simply running with degree 0 but avoids
@@ -566,7 +571,7 @@ public:
mmap ( _mmap ) , // I enforce the passing in of a mapping, even though it
// may not be used at all. TODO: can I do better?
workspace_size ( ( _spline_degree + 1 ) * dimension ) ,
- window_size ( std::pow ( ORDER , int(dimension) ) )
+ window_size ( std::pow ( _spline_degree + 1 , int(dimension) ) )
{
// initalize the weight functors. In this constructor, we use only bspline weight
// functors, even though the evaluator can operate with all weight functors
@@ -631,7 +636,9 @@ public:
/// simplified constructor from a bspline object
/// when using the higher-level interface to vspline's facilities - via class bspline -
/// class bspline objects already have a fair amount of metadata which are perfectly
- /// sufficient to create a suitable evaluator object:
+ /// sufficient to create a suitable evaluator object. If evaluation of the spline's value
+ /// (no derivative spec) is wanted, all this constructor takes is a const reference
+ /// to a bspline object, which is about as simple as it can get:
evaluator ( const bspline < value_type , dimension > & bspl ,
derivative_spec_type _derivative = derivative_spec_type ( 0 ) )
@@ -930,7 +937,7 @@ public:
ele_type weight_data [ workspace_size ] ; // get space for the weights
MultiArrayView < 2 , ele_type > // package them in a MultiArrayView
- weight ( Shape2 ( ORDER , dimension ) , // with dimension sets of ORDER weights
+ weight ( Shape2 ( ORDER , dimension ) , // with dimension sets of ORDER weights
weight_data ) ; // using the space claimed above
// now we call obtain_weights, which will fill in 'weight' with weights for the
@@ -977,6 +984,8 @@ public:
mmap ( c , select , tune ) ;
}
+ // after applying the mapping, we now have the 'split' coordinate in 'select'
+ // and 'tune', and we delegate to the next level:
eval ( select , tune , result ) ;
}
diff --git a/filter.h b/filter.h
index 2737370..e4642b0 100644
--- a/filter.h
+++ b/filter.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/mapping.h b/mapping.h
index 7bcc05b..073bd74 100644
--- a/mapping.h
+++ b/mapping.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/multithread.h b/multithread.h
index ffa1c19..72b2713 100644
--- a/multithread.h
+++ b/multithread.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
@@ -76,10 +84,13 @@
/// tasks, leaving the partitioning to code inside multithread(), resulting in some
/// default partitioning provided by a suitable overload of function partition().
/// This is the commonly used variant, since it's usually not necessary to obtain
-/// a partitioning other than the default one.
+/// a partitioning other than the default one. The notable exception here is partitioning
+/// for b-spline prefiltering, where the axis along which we apply the filter must
+/// not be split, and hence the prefiltering code partitions the range itself and
+/// uses the variant of multithread() which takes a partitioning.
///
/// The tasks, once prepared, are handed over to a 'joint_task' object which handles
-/// the interaction with the thread pool (in thread_pool.cc). While my initial code
+/// the interaction with the thread pool (in thread_pool.h). While my initial code
/// used one thread per task, this turned out inefficient, because it was not granular
/// enough: the slowest thread became the limiting factor. Now the job at hand is split
/// into more individual tasks (something like 8 times the number of cores), resulting
@@ -92,9 +103,9 @@
/// ready, I chose to suspend the calling thread until the result arrives. This makes
/// the logic simpler, and should be what most use cases need: there is often little else
/// to do but to wait for the result anyway. If asynchronous operation is needed, a thread
-/// can be launched to initiate and collect from the multithreading. It's safe to have several
-/// threads using this multithreading code, since each task is linked to a 'coordinator',
-/// see struct joint_task below.
+/// can be launched to initiate and collect from the multithreading. It's safe to have
+/// several threads using this multithreading code, since each task is linked to a
+/// 'coordinator', see struct joint_task below.
#ifndef VSPLINE_MULTITHREAD_H
#define VSPLINE_MULTITHREAD_H
@@ -189,7 +200,11 @@ using shape_partition_type = partition_type < shape_range_type < dimension > > ;
/// along the outermost axis that can be split n-ways. The additional parameter
/// 'forbid' prevents that particular axis from being split. The split may succeed
/// producing n or less ranges, and if 'shape' can't be split at all, a single range
-/// encompassing the whole of 'shape' will be returned in the result vector.
+/// encompassing the whole of 'shape' will be returned in the result vector. This
+/// object is used for partitioning when one axis has to be preserved intact, like
+/// for b-spline prefiltering, but it's not used per default for all shape splitting,
+/// since the resulting partitioning performs not so well in certain situations
+/// (see the partitioning into tiles below for a better general-purpose splitter)
// TODO: with some shapes, splitting will result in subranges which aren't optimal
// for b-spline prefiltering (these are fastest with extents which are a multiple of
@@ -273,41 +288,44 @@ struct shape_splitter
}
} ;
-/// for any dimension d, we specialize function partition() for shape_range_type<d>.
-/// we use shape_splitter to perform the split. This function template
-/// provides the default partitioning mechanism for a shape_range, which is used by
-/// the second variant of multithread(), which is called with a range and a number
-/// of desired threads instead of a ready-made partitioning.
-
-// template < int d >
-// partition_type < shape_range_type<d> >
-// partition ( shape_range_type<d> range , int nparts )
-// {
-// if ( range[0].any() )
-// {
-// // the lower limit of the range is not at the origin, so get the shape
-// // of the region between range[0] and range[1], call shape_splitter with
-// // this shape, and add the offset to the lower limit of the original range
-// // to the partial ranges in the result
-// auto shape = range[1] - range[0] ;
-// auto res = shape_splitter < d > :: part ( shape , nparts ) ;
-// for ( auto & r : res )
-// {
-// r[0] += range[0] ;
-// r[1] += range[0] ;
-// }
-// return res ;
-// }
-// // if range[0] is at the origin, we don't have use an offset
-// return shape_splitter < d > :: part ( range[1] , nparts ) ;
-// }
-
-// alternative partitioning into tiles. For the optimal situation, where
-// the view isn't rotated or pitched much, the partitioning into bunches
-// of lines (above) seems to perform slightly better, but with more difficult
-// transformations (like 90 degree rotation), performance suffers (like, -20%),
-// whereas with this tiled partitioning it is roughly the same, supposedly due
-// to identical locality in both cases. So currently I am using this partitioning.
+// /// for any dimension d, we specialize function partition() for shape_range_type<d>.
+// /// we use shape_splitter to perform the split. This function template
+// /// provides the default partitioning mechanism for a shape_range, which is used by
+// /// the second variant of multithread(), which is called with a range and a number
+// /// of desired threads instead of a ready-made partitioning. This currently unused
+// /// code would make shape_splitter the default splitter.
+//
+// // template < int d >
+// // partition_type < shape_range_type<d> >
+// // partition ( shape_range_type<d> range , int nparts )
+// // {
+// // if ( range[0].any() )
+// // {
+// // // the lower limit of the range is not at the origin, so get the shape
+// // // of the region between range[0] and range[1], call shape_splitter with
+// // // this shape, and add the offset to the lower limit of the original range
+// // // to the partial ranges in the result
+// // auto shape = range[1] - range[0] ;
+// // auto res = shape_splitter < d > :: part ( shape , nparts ) ;
+// // for ( auto & r : res )
+// // {
+// // r[0] += range[0] ;
+// // r[1] += range[0] ;
+// // }
+// // return res ;
+// // }
+// // // if range[0] is at the origin, we don't have use an offset
+// // return shape_splitter < d > :: part ( range[1] , nparts ) ;
+// // }
+
+/// alternative partitioning into tiles. For the optimal situation, where
+/// the view isn't rotated or pitched much, the partitioning into bunches
+/// of lines (above) seems to perform slightly better, but with more difficult
+/// transformations (like 90 degree rotation), performance suffers (like, -20%),
+/// whereas with this tiled partitioning it is roughly the same, supposedly due
+/// to identical locality in both cases. So currently I am using this partitioning.
+/// note that the current implementation ignores the argument 'nparts' and
+/// produces tiles 160X160.
// TODO code is a bit clumsy...
template < int d >
@@ -316,9 +334,14 @@ partition ( shape_range_type<d> range ,
int nparts = default_njobs )
{
auto shape = range[1] - range[0] ;
- int nelements = prod ( shape ) ;
- int ntile = nelements / nparts ;
- int nedge = 160 ; // heuristic, fixed size // pow ( ntile , ( 1.0 / d ) ) ;
+
+// currently disregarding incoming nparts parameter:
+// int nelements = prod ( shape ) ;
+// int ntile = nelements / nparts ;
+// int nedge = pow ( ntile , ( 1.0 / d ) ) ;
+
+ int nedge = 160 ; // instead: heuristic, fixed size tiles
+
auto tiled_shape = shape / nedge ;
typedef std::vector < int > stopv ;
@@ -427,7 +450,7 @@ void action_wrapper ( std::function < void() > payload ,
std::lock_guard<std::mutex> lk ( * p_pool_mutex ) ;
if ( ++ ( * p_done ) == nparts ) ;
{
- // this was the last action originating from p_coordinator
+ // this was the last action originating from the coordinator
// notify the coordinator that the joint task is now complete
p_pool_cv->notify_one() ;
}
diff --git a/poles.h b/poles.h
index e244548..59c6b74 100644
--- a/poles.h
+++ b/poles.h
@@ -5,6 +5,14 @@
/* */
/* Copyright 2015 - 2017 by Kay F. Jahnke */
/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
+/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
/* files (the "Software"), to deal in the Software without */
diff --git a/prefilter.h b/prefilter.h
index 1bce683..57d8a32 100644
--- a/prefilter.h
+++ b/prefilter.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/remap.h b/remap.h
index 762c693..bb7d0da 100644
--- a/remap.h
+++ b/remap.h
@@ -5,6 +5,14 @@
/* */
/* Copyright 2015 - 2017 by Kay F. Jahnke */
/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
+/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
/* files (the "Software"), to deal in the Software without */
@@ -232,7 +240,9 @@ struct _fill < generator_type , 1 >
for ( int a = 0 ; a < aggregates ; a++ , destination += vsize * output.stride(0) )
{
+ // here we generate to a simdized target type
gen ( target_buffer ) ;
+ // and store it to destination using a helper routine of the functor
f.store ( target_buffer , destination , output.stride(0) ) ;
}
}
@@ -263,8 +273,8 @@ struct _fill < generator_type , 1 >
template < typename generator_type , // functor object yielding values
int dim_out > // number of dimensions of output array
-void st_fill ( shape_range_type < dim_out > range ,
- generator_type * const p_gen ,
+void st_fill ( shape_range_type < dim_out > range ,
+ generator_type * const p_gen ,
MultiArrayView < dim_out , typename generator_type::value_type > * p_output ,
bool use_vc = true )
{
diff --git a/thread_pool.h b/thread_pool.h
index 0214b44..98cdcd1 100644
--- a/thread_pool.h
+++ b/thread_pool.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/unary_functor.h b/unary_functor.h
index 5ddfdd6..e8979ed 100644
--- a/unary_functor.h
+++ b/unary_functor.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
diff --git a/vspline.h b/vspline.h
index 60c3541..bf89f9c 100644
--- a/vspline.h
+++ b/vspline.h
@@ -3,7 +3,15 @@
/* vspline - a set of generic tools for creation and evaluation */
/* of uniform b-splines */
/* */
-/* Copyright 2015, 2016 by Kay F. Jahnke */
+/* Copyright 2015 - 2017 by Kay F. Jahnke */
+/* */
+/* The git repository for this software is at */
+/* */
+/* https://bitbucket.org/kfj/vspline */
+/* */
+/* Please direct questions, bug reports, and contributions to */
+/* */
+/* kfjahnke+vspline at gmail.com */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/vspline.git
More information about the debian-science-commits
mailing list