sequenzo 0.1.17__cp311-cp311-win_amd64.whl → 0.1.19__cp311-cp311-win_amd64.whl

sequenzo/dissimilarity_measures/src/eigen/debug/gdb/__init__.py

@@ -1 +0,0 @@
-# Intentionally empty

sequenzo/dissimilarity_measures/src/eigen/debug/gdb/printers.py

@@ -1,314 +0,0 @@
-# -*- coding: utf-8 -*-
-# This file is part of Eigen, a lightweight C++ template library
-# for linear algebra.
-#
-# Copyright (C) 2009 Benjamin Schindler <bschindler@inf.ethz.ch>
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-# Pretty printers for Eigen::Matrix
-# This is still pretty basic as the python extension to gdb is still pretty basic. 
-# It cannot handle complex eigen types and it doesn't support many of the other eigen types
-# This code supports fixed size as well as dynamic size matrices
-
-# To use it:
-#
-# * Create a directory and put the file as well as an empty __init__.py in 
-#   that directory.
-# * Create a ~/.gdbinit file, that contains the following:
-#      python
-#      import sys
-#      sys.path.insert(0, '/path/to/eigen/printer/directory')
-#      from printers import register_eigen_printers
-#      register_eigen_printers (None)
-#      end
-
-import gdb
-import re
-import itertools
-from bisect import bisect_left
-
-# Basic row/column iteration code for use with Sparse and Dense matrices
-class _MatrixEntryIterator(object):
-	
-	def __init__ (self, rows, cols, rowMajor):
-		self.rows = rows
-		self.cols = cols
-		self.currentRow = 0
-		self.currentCol = 0
-		self.rowMajor = rowMajor
-
-	def __iter__ (self):
-		return self
-
-	def next(self):
-                return self.__next__()  # Python 2.x compatibility
-
-	def __next__(self):
-		row = self.currentRow
-		col = self.currentCol
-		if self.rowMajor == 0:
-			if self.currentCol >= self.cols:
-				raise StopIteration
-				
-			self.currentRow = self.currentRow + 1
-			if self.currentRow >= self.rows:
-				self.currentRow = 0
-				self.currentCol = self.currentCol + 1
-		else:
-			if self.currentRow >= self.rows:
-				raise StopIteration
-				
-			self.currentCol = self.currentCol + 1
-			if self.currentCol >= self.cols:
-				self.currentCol = 0
-				self.currentRow = self.currentRow + 1
-
-		return (row, col)
-
-class EigenMatrixPrinter:
-	"Print Eigen Matrix or Array of some kind"
-
-	def __init__(self, variety, val):
-		"Extract all the necessary information"
-		
-		# Save the variety (presumably "Matrix" or "Array") for later usage
-		self.variety = variety
-		
-		# The gdb extension does not support value template arguments - need to extract them by hand
-		type = val.type
-		if type.code == gdb.TYPE_CODE_REF:
-			type = type.target()
-		self.type = type.unqualified().strip_typedefs()
-		tag = self.type.tag
-		regex = re.compile('\<.*\>')
-		m = regex.findall(tag)[0][1:-1]
-		template_params = m.split(',')
-		template_params = [x.replace(" ", "") for x in template_params]
-		
-		if template_params[1] == '-0x00000000000000001' or template_params[1] == '-0x000000001' or template_params[1] == '-1':
-			self.rows = val['m_storage']['m_rows']
-		else:
-			self.rows = int(template_params[1])
-		
-		if template_params[2] == '-0x00000000000000001' or template_params[2] == '-0x000000001' or template_params[2] == '-1':
-			self.cols = val['m_storage']['m_cols']
-		else:
-			self.cols = int(template_params[2])
-		
-		self.options = 0 # default value
-		if len(template_params) > 3:
-			self.options = template_params[3];
-		
-		self.rowMajor = (int(self.options) & 0x1)
-		
-		self.innerType = self.type.template_argument(0)
-		
-		self.val = val
-		
-		# Fixed size matrices have a struct as their storage, so we need to walk through this
-		self.data = self.val['m_storage']['m_data']
-		if self.data.type.code == gdb.TYPE_CODE_STRUCT:
-			self.data = self.data['array']
-			self.data = self.data.cast(self.innerType.pointer())
-			
-	class _iterator(_MatrixEntryIterator):
-		def __init__ (self, rows, cols, dataPtr, rowMajor):
-			super(EigenMatrixPrinter._iterator, self).__init__(rows, cols, rowMajor)
-
-			self.dataPtr = dataPtr
-
-		def __next__(self):
-			
-			row, col = super(EigenMatrixPrinter._iterator, self).__next__()
-			
-			item = self.dataPtr.dereference()
-			self.dataPtr = self.dataPtr + 1
-			if (self.cols == 1): #if it's a column vector
-				return ('[%d]' % (row,), item)
-			elif (self.rows == 1): #if it's a row vector
-				return ('[%d]' % (col,), item)
-			return ('[%d,%d]' % (row, col), item)
-			
-	def children(self):
-		
-		return self._iterator(self.rows, self.cols, self.data, self.rowMajor)
-		
-	def to_string(self):
-		return "Eigen::%s<%s,%d,%d,%s> (data ptr: %s)" % (self.variety, self.innerType, self.rows, self.cols, "RowMajor" if self.rowMajor else  "ColMajor", self.data)
-
-class EigenSparseMatrixPrinter:
-	"Print an Eigen SparseMatrix"
-
-	def __init__(self, val):
-		"Extract all the necessary information"
-
-		type = val.type
-		if type.code == gdb.TYPE_CODE_REF:
-			type = type.target()
-		self.type = type.unqualified().strip_typedefs()
-		tag = self.type.tag
-		regex = re.compile('\<.*\>')
-		m = regex.findall(tag)[0][1:-1]
-		template_params = m.split(',')
-		template_params = [x.replace(" ", "") for x in template_params]
-
-		self.options = 0
-		if len(template_params) > 1:
-			self.options = template_params[1];
-		
-		self.rowMajor = (int(self.options) & 0x1)
-		
-		self.innerType = self.type.template_argument(0)
-		
-		self.val = val
-
-		self.data = self.val['m_data']
-		self.data = self.data.cast(self.innerType.pointer())
-
-	class _iterator(_MatrixEntryIterator):
-		def __init__ (self, rows, cols, val, rowMajor):
-			super(EigenSparseMatrixPrinter._iterator, self).__init__(rows, cols, rowMajor)
-
-			self.val = val
-			
-		def __next__(self):
-			
-			row, col = super(EigenSparseMatrixPrinter._iterator, self).__next__()
-				
-			# repeat calculations from SparseMatrix.h:
-			outer = row if self.rowMajor else col
-			inner = col if self.rowMajor else row
-			start = self.val['m_outerIndex'][outer]
-			end = ((start + self.val['m_innerNonZeros'][outer]) if self.val['m_innerNonZeros'] else
-			       self.val['m_outerIndex'][outer+1])
-
-			# and from CompressedStorage.h:
-			data = self.val['m_data']
-			if start >= end:
-				item = 0
-			elif (end > start) and (inner == data['m_indices'][end-1]):
-				item = data['m_values'][end-1]
-			else:
-				# create Python index list from the target range within m_indices
-				indices = [data['m_indices'][x] for x in range(int(start), int(end)-1)]
-				# find the index with binary search
-				idx = int(start) + bisect_left(indices, inner)
-				if ((idx < end) and (data['m_indices'][idx] == inner)):
-					item = data['m_values'][idx]
-				else:
-					item = 0
-
-			return ('[%d,%d]' % (row, col), item)
-
-	def children(self):
-		if self.data:
-			return self._iterator(self.rows(), self.cols(), self.val, self.rowMajor)
-
-		return iter([])   # empty matrix, for now
-
-
-	def rows(self):
-		return self.val['m_outerSize'] if self.rowMajor else self.val['m_innerSize']
-
-	def cols(self):
-		return self.val['m_innerSize'] if self.rowMajor else self.val['m_outerSize']
-
-	def to_string(self):
-
-		if self.data:
-			status = ("not compressed" if self.val['m_innerNonZeros'] else "compressed")
-		else:
-			status = "empty"
-		dimensions  = "%d x %d" % (self.rows(), self.cols())
-		layout      = "row" if self.rowMajor else "column"
-
-		return "Eigen::SparseMatrix<%s>, %s, %s major, %s" % (
-			self.innerType, dimensions, layout, status )
-
-class EigenQuaternionPrinter:
-	"Print an Eigen Quaternion"
-	
-	def __init__(self, val):
-		"Extract all the necessary information"
-		# The gdb extension does not support value template arguments - need to extract them by hand
-		type = val.type
-		if type.code == gdb.TYPE_CODE_REF:
-			type = type.target()
-		self.type = type.unqualified().strip_typedefs()
-		self.innerType = self.type.template_argument(0)
-		self.val = val
-		
-		# Quaternions have a struct as their storage, so we need to walk through this
-		self.data = self.val['m_coeffs']['m_storage']['m_data']['array']
-		self.data = self.data.cast(self.innerType.pointer())
-			
-	class _iterator:
-		def __init__ (self, dataPtr):
-			self.dataPtr = dataPtr
-			self.currentElement = 0
-			self.elementNames = ['x', 'y', 'z', 'w']
-			
-		def __iter__ (self):
-			return self
-	
-		def next(self):
-			return self.__next__()  # Python 2.x compatibility
-
-		def __next__(self):
-			element = self.currentElement
-			
-			if self.currentElement >= 4: #there are 4 elements in a quanternion
-				raise StopIteration
-			
-			self.currentElement = self.currentElement + 1
-			
-			item = self.dataPtr.dereference()
-			self.dataPtr = self.dataPtr + 1
-			return ('[%s]' % (self.elementNames[element],), item)
-			
-	def children(self):
-		
-		return self._iterator(self.data)
-	
-	def to_string(self):
-		return "Eigen::Quaternion<%s> (data ptr: %s)" % (self.innerType, self.data)
-
-def build_eigen_dictionary ():
-	pretty_printers_dict[re.compile('^Eigen::Quaternion<.*>$')] = lambda val: EigenQuaternionPrinter(val)
-	pretty_printers_dict[re.compile('^Eigen::Matrix<.*>$')] = lambda val: EigenMatrixPrinter("Matrix", val)
-	pretty_printers_dict[re.compile('^Eigen::SparseMatrix<.*>$')] = lambda val: EigenSparseMatrixPrinter(val)
-	pretty_printers_dict[re.compile('^Eigen::Array<.*>$')]  = lambda val: EigenMatrixPrinter("Array",  val)
-
-def register_eigen_printers(obj):
-	"Register eigen pretty-printers with objfile Obj"
-
-	if obj == None:
-		obj = gdb
-	obj.pretty_printers.append(lookup_function)
-
-def lookup_function(val):
-	"Look-up and return a pretty-printer that can print va."
-	
-	type = val.type
-	
-	if type.code == gdb.TYPE_CODE_REF:
-		type = type.target()
-	
-	type = type.unqualified().strip_typedefs()
-	
-	typename = type.tag
-	if typename == None:
-		return None
-	
-	for function in pretty_printers_dict:
-		if function.search(typename):
-			return pretty_printers_dict[function](val)
-	
-	return None
-
-pretty_printers_dict = {}
-
-build_eigen_dictionary ()

sequenzo/dissimilarity_measures/src/eigen/demos/mandelbrot/mandelbrot.h

@@ -1,71 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef MANDELBROT_H
-#define MANDELBROT_H
-
-#include <Eigen/Core>
-#include <QtGui/QApplication>
-#include <QtGui/QWidget>
-#include <QtCore/QThread>
-
-class MandelbrotWidget;
-
-class MandelbrotThread : public QThread
-{
-    friend class MandelbrotWidget;
-    MandelbrotWidget *widget;
-    long long total_iter;
-    int id, max_iter;
-    bool single_precision;
-
-  public:
-    MandelbrotThread(MandelbrotWidget *w, int i) : widget(w), id(i) {}
-    void run();
-    template<typename Real> void render(int img_width, int img_height);
-};
-
-class MandelbrotWidget : public QWidget
-{
-    Q_OBJECT
-
-    friend class MandelbrotThread;
-    Eigen::Vector2d center;
-    double xradius;
-    int size;
-    unsigned char *buffer;
-    QPoint lastpos;
-    int draft;
-    MandelbrotThread **threads;
-    int threadcount;
-
-  protected:
-    void resizeEvent(QResizeEvent *);
-    void paintEvent(QPaintEvent *);
-    void mousePressEvent(QMouseEvent *event);
-    void mouseMoveEvent(QMouseEvent *event);
-
-  public:
-    MandelbrotWidget() : QWidget(), center(0,0), xradius(2),
-                         size(0), buffer(0), draft(16)
-    {
-      setAutoFillBackground(false);
-      threadcount = QThread::idealThreadCount();
-      threads = new MandelbrotThread*[threadcount];
-      for(int th = 0; th < threadcount; th++) threads[th] = new MandelbrotThread(this, th);
-    }
-    ~MandelbrotWidget()
-    {
-      if(buffer) delete[]buffer;
-      for(int th = 0; th < threadcount; th++) delete threads[th];
-      delete[] threads;
-    }
-};
-
-#endif // MANDELBROT_H

sequenzo/dissimilarity_measures/src/eigen/demos/mix_eigen_and_c/binary_library.h

@@ -1,71 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// This is a pure C header, no C++ here.
-// The functions declared here will be implemented in C++ but
-// we don't have to know, because thanks to the extern "C" syntax,
-// they will be compiled to C object code.
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-  // just dummy empty structs to give different pointer types,
-  // instead of using void* which would be type unsafe
-  struct C_MatrixXd {};
-  struct C_Map_MatrixXd {};
-
-  // the C_MatrixXd class, wraps some of the functionality
-  // of Eigen::MatrixXd.
-  struct C_MatrixXd* MatrixXd_new(int rows, int cols);
-  void    MatrixXd_delete     (struct C_MatrixXd *m);
-  double* MatrixXd_data       (struct C_MatrixXd *m);
-  void    MatrixXd_set_zero   (struct C_MatrixXd *m);
-  void    MatrixXd_resize     (struct C_MatrixXd *m, int rows, int cols);
-  void    MatrixXd_copy       (struct C_MatrixXd *dst,
-                               const struct C_MatrixXd *src);
-  void    MatrixXd_copy_map   (struct C_MatrixXd *dst,
-                               const struct C_Map_MatrixXd *src);  
-  void    MatrixXd_set_coeff  (struct C_MatrixXd *m,
-                               int i, int j, double coeff);
-  double  MatrixXd_get_coeff  (const struct C_MatrixXd *m,
-                               int i, int j);
-  void    MatrixXd_print      (const struct C_MatrixXd *m);
-  void    MatrixXd_add        (const struct C_MatrixXd *m1,
-                               const struct C_MatrixXd *m2,
-                               struct C_MatrixXd *result);  
-  void    MatrixXd_multiply   (const struct C_MatrixXd *m1,
-                               const struct C_MatrixXd *m2,
-                               struct C_MatrixXd *result);
-  
-  // the C_Map_MatrixXd class, wraps some of the functionality
-  // of Eigen::Map<MatrixXd>
-  struct C_Map_MatrixXd* Map_MatrixXd_new(double *array, int rows, int cols);
-  void   Map_MatrixXd_delete     (struct C_Map_MatrixXd *m);
-  void   Map_MatrixXd_set_zero   (struct C_Map_MatrixXd *m);
-  void   Map_MatrixXd_copy       (struct C_Map_MatrixXd *dst,
-                                  const struct C_Map_MatrixXd *src);
-  void   Map_MatrixXd_copy_matrix(struct C_Map_MatrixXd *dst,
-                                  const struct C_MatrixXd *src);  
-  void   Map_MatrixXd_set_coeff  (struct C_Map_MatrixXd *m,
-                                  int i, int j, double coeff);
-  double Map_MatrixXd_get_coeff  (const struct C_Map_MatrixXd *m,
-                                  int i, int j);
-  void   Map_MatrixXd_print      (const struct C_Map_MatrixXd *m);
-  void   Map_MatrixXd_add        (const struct C_Map_MatrixXd *m1,
-                                  const struct C_Map_MatrixXd *m2,
-                                  struct C_Map_MatrixXd *result);  
-  void   Map_MatrixXd_multiply   (const struct C_Map_MatrixXd *m1,
-                                  const struct C_Map_MatrixXd *m2,
-                                  struct C_Map_MatrixXd *result);
-
-#ifdef __cplusplus
-} // end extern "C"
-#endif

sequenzo/dissimilarity_measures/src/eigen/demos/opengl/camera.h

@@ -1,118 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CAMERA_H
-#define EIGEN_CAMERA_H
-
-#include <Eigen/Geometry>
-#include <QObject>
-// #include <frame.h>
-
-class Frame
-{
-  public:
-    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-    
-    inline Frame(const Eigen::Vector3f& pos = Eigen::Vector3f::Zero(),
-                 const Eigen::Quaternionf& o = Eigen::Quaternionf())
-      : orientation(o), position(pos)
-    {}
-    Frame lerp(float alpha, const Frame& other) const
-    {
-      return Frame((1.f-alpha)*position + alpha * other.position,
-                   orientation.slerp(alpha,other.orientation));
-    }
-
-    Eigen::Quaternionf orientation;
-    Eigen::Vector3f position;
-};
-
-class Camera
-{
-  public:
-    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-
-    Camera(void);
-    
-    Camera(const Camera& other);
-    
-    virtual ~Camera();
-    
-    Camera& operator=(const Camera& other);
-    
-    void setViewport(uint offsetx, uint offsety, uint width, uint height);
-    void setViewport(uint width, uint height);
-    
-    inline uint vpX(void) const { return mVpX; }
-    inline uint vpY(void) const { return mVpY; }
-    inline uint vpWidth(void) const { return mVpWidth; }
-    inline uint vpHeight(void) const { return mVpHeight; }
-
-    inline float fovY(void) const { return mFovY; }
-    void setFovY(float value);
-    
-    void setPosition(const Eigen::Vector3f& pos);
-    inline const Eigen::Vector3f& position(void) const { return mFrame.position; }
-
-    void setOrientation(const Eigen::Quaternionf& q);
-    inline const Eigen::Quaternionf& orientation(void) const { return mFrame.orientation; }
-
-    void setFrame(const Frame& f);
-    const Frame& frame(void) const { return mFrame; }
-    
-    void setDirection(const Eigen::Vector3f& newDirection);
-    Eigen::Vector3f direction(void) const;
-    void setUp(const Eigen::Vector3f& vectorUp);
-    Eigen::Vector3f up(void) const;
-    Eigen::Vector3f right(void) const;
-    
-    void setTarget(const Eigen::Vector3f& target);
-    inline const Eigen::Vector3f& target(void) { return mTarget; }
-    
-    const Eigen::Affine3f& viewMatrix(void) const;
-    const Eigen::Matrix4f& projectionMatrix(void) const;
-    
-    void rotateAroundTarget(const Eigen::Quaternionf& q);
-    void localRotate(const Eigen::Quaternionf& q);
-    void zoom(float d);
-    
-    void localTranslate(const Eigen::Vector3f& t);
-    
-    /** Setup OpenGL matrices and viewport */
-    void activateGL(void);
-    
-    Eigen::Vector3f unProject(const Eigen::Vector2f& uv, float depth, const Eigen::Matrix4f& invModelview) const;
-    Eigen::Vector3f unProject(const Eigen::Vector2f& uv, float depth) const;
-    
-  protected:
-    void updateViewMatrix(void) const;
-    void updateProjectionMatrix(void) const;
-
-  protected:
-
-    uint mVpX, mVpY;
-    uint mVpWidth, mVpHeight;
-
-    Frame mFrame;
-    
-    mutable Eigen::Affine3f mViewMatrix;
-    mutable Eigen::Matrix4f mProjectionMatrix;
-
-    mutable bool mViewIsUptodate;
-    mutable bool mProjIsUptodate;
-
-    // used by rotateAroundTarget
-    Eigen::Vector3f mTarget;
-    
-    float mFovY;
-    float mNearDist;
-    float mFarDist;
-};
-
-#endif // EIGEN_CAMERA_H