pytexgen 1.0.0__tar.gz

pytexgen-1.0.0/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(xargs -0 ls -1)",
+      "Bash(grep -rn \"def.*/$\\\\|def.*/, \" /e/Code/TexGen-master --include=\"*.py\")",
+      "Bash(find /e/Code/TexGen-master -name \"*.py\" -exec grep -l \"typing\\\\|Type\\\\|Optional\\\\|List\\\\|Dict\\\\|Tuple\" {} \\\\;)",
+      "Bash(grep -rn \"\\\\.pyi$\\\\|__annotations__\" /e/Code/TexGen-master --include=\"*.py\")"
+    ]
+  }
+}

pytexgen-1.0.0/.gitignore

@@ -0,0 +1,23 @@
+# Build artifacts
+build/
+dist/
+*.egg-info/
+__pycache__/
+*.pyc
+*.pyo
+*.so
+*.pyd
+*.dll
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Generated SWIG files
+Python/Core_wrap.cxx
+Python/Core.py

pytexgen-1.0.0/CMakeLists.txt

@@ -0,0 +1,96 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.17)
+PROJECT(TexGen LANGUAGES C CXX)
+
+# ============================================================================
+# scikit-build-core detection
+# When building via `pip install .` or `python -m build`, SKBUILD is set
+# automatically by scikit-build-core.
+# ============================================================================
+if(DEFINED SKBUILD)
+    message(STATUS "Building via scikit-build-core (wheel mode)")
+    # In wheel mode, find the Python interpreter that scikit-build-core provides
+    find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
+endif()
+
+# ============================================================================
+# Compiler flags
+# ============================================================================
+ADD_DEFINITIONS(-DSWIG_NO_CRT_SECURE_NO_DEPRECATE)
+IF(MSVC)
+    ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
+ENDIF()
+
+IF(UNIX)
+    ADD_DEFINITIONS(-Wno-deprecated)
+    # Ensure all static libs are built with PIC so they can link into shared _Core
+    SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ENDIF()
+
+# ============================================================================
+# Output paths
+# ============================================================================
+IF(WIN32)
+    SET(REAL_OUTPUT_PATH ${TexGen_BINARY_DIR}/$(OutDir))
+ELSE()
+    SET(REAL_OUTPUT_PATH ${TexGen_BINARY_DIR})
+ENDIF()
+
+# ============================================================================
+# Build options
+# ============================================================================
+SET(BUILD_RENDERER ON CACHE BOOL "Enable rendering using VTK.")
+SET(BUILD_PYTHON_INTERFACE ON CACHE BOOL "Enable the Python interface.")
+SET(BUILD_GUI ON CACHE BOOL "Build the graphical user interface.")
+SET(BUILD_EXAMPLES OFF CACHE BOOL "Build the examples.")
+SET(BUILD_UNIT_TESTS OFF CACHE BOOL "Build the unit tests to ensure the software is working as expected.")
+SET(BUILD_CASCADE_EXPORT OFF CACHE BOOL "Build module to export geometry to Open CASCADE.")
+SET(BUILD_SHARED ON CACHE BOOL "Build shared libraries (set OFF for wheel packaging)")
+SET(BUILD_DOCUMENTATION OFF CACHE BOOL "Build documentation using doxygen")
+SET(BUILD_PROFILE OFF CACHE BOOL "Build profiling")
+
+IF(BUILD_GUI)
+    IF(NOT BUILD_RENDERER)
+        MESSAGE("The renderer is needed in order to build the graphical user interface.\nSet BUILD_RENDERER ON.")
+    ENDIF()
+    IF(NOT BUILD_PYTHON_INTERFACE)
+        MESSAGE("The Python interface is needed in order to build the graphical user interface.\nSet BUILD_PYTHON_INTERFACE ON.")
+    ENDIF()
+ENDIF()
+
+# ============================================================================
+# Subdirectories - core C++ libraries (always built as static for bundling)
+# ============================================================================
+ADD_SUBDIRECTORY(Core)
+ADD_SUBDIRECTORY(Triangle)
+ADD_SUBDIRECTORY(Octree)
+ADD_SUBDIRECTORY(tinyxml)
+ADD_SUBDIRECTORY(CSparse)
+ADD_SUBDIRECTORY(tetgenlib)
+ADD_SUBDIRECTORY(LatinHypercube)
+
+IF(BUILD_RENDERER)
+    ADD_SUBDIRECTORY(Renderer)
+ENDIF()
+IF(BUILD_CASCADE_EXPORT)
+    ADD_SUBDIRECTORY(Export)
+ENDIF()
+IF(BUILD_PYTHON_INTERFACE)
+    ADD_SUBDIRECTORY(Python)
+ENDIF()
+IF(BUILD_GUI)
+    ADD_SUBDIRECTORY(GUI)
+ENDIF()
+IF(BUILD_EXAMPLES)
+    ADD_SUBDIRECTORY(Examples)
+ENDIF()
+IF(BUILD_UNIT_TESTS)
+    ADD_SUBDIRECTORY(UnitTests)
+ENDIF()
+IF(BUILD_PROFILE)
+    ADD_SUBDIRECTORY(ProfileTests)
+ENDIF()
+
+SET(LIBRARY_OUTPUT_PATH ${TexGen_BINARY_DIR} CACHE INTERNAL "Single output directory for building all libraries.")
+SET(EXECUTABLE_OUTPUT_PATH ${TexGen_BINARY_DIR} CACHE INTERNAL "Single output directory for building all executables.")
+CONFIGURE_FILE(${TexGen_SOURCE_DIR}/TexGenConfig.cmake.in
+               ${TexGen_BINARY_DIR}/TexGenConfig.cmake)

pytexgen-1.0.0/CSparse/CMakeLists.txt

@@ -0,0 +1,5 @@
+FILE(GLOB CSPARSE_SOURCE_FILES Source/*.c)
+
+ADD_LIBRARY(CSparse STATIC ${CSPARSE_SOURCE_FILES} Include/cs.h)
+SET_TARGET_PROPERTIES(CSparse PROPERTIES POSITION_INDEPENDENT_CODE ON)
+INCLUDE_DIRECTORIES(Include)

pytexgen-1.0.0/CSparse/Demo/Makefile

@@ -0,0 +1,39 @@
+CC = cc
+CFLAGS = -O
+
+I = -I../Include
+
+CS = ../Lib/libcsparse.a
+
+all: lib cs_demo1 cs_demo2 cs_demo3
+	- ./cs_demo1 < ../Matrix/t1
+	- ./cs_demo2 < ../Matrix/t1
+	- ./cs_demo2 < ../Matrix/ash219
+	- ./cs_demo2 < ../Matrix/bcsstk01
+	- ./cs_demo2 < ../Matrix/fs_183_1
+	- ./cs_demo2 < ../Matrix/mbeacxc
+	- ./cs_demo2 < ../Matrix/west0067
+	- ./cs_demo2 < ../Matrix/lp_afiro
+	- ./cs_demo2 < ../Matrix/bcsstk16
+	- ./cs_demo3 < ../Matrix/bcsstk01
+	- ./cs_demo3 < ../Matrix/bcsstk16
+
+lib:
+	( cd ../Lib ; $(MAKE) )
+
+cs_demo1: lib cs_demo1.c Makefile
+	$(CC) $(CFLAGS) $(I) -o cs_demo1 cs_demo1.c $(CS) -lm
+
+cs_demo2: lib cs_demo2.c cs_demo.c cs_demo.h Makefile
+	$(CC) $(CFLAGS) $(I) -o cs_demo2 cs_demo2.c cs_demo.c $(CS) -lm
+
+cs_demo3: lib cs_demo3.c cs_demo.c cs_demo.h Makefile
+	$(CC) $(CFLAGS) $(I) -o cs_demo3 cs_demo3.c cs_demo.c $(CS) -lm
+
+clean:
+	rm -f *.o
+
+purge: distclean
+
+distclean: clean
+	rm -f cs_demo1 cs_demo2 cs_demo3 *.a

pytexgen-1.0.0/CSparse/Demo/README.txt

@@ -0,0 +1,4 @@
+CSparse/Demo:  to compile a run the demos, just type "make" in this directory.
+The printed residuals should all be small, except for the mbeacxc matrix
+(which is numerically and structurally singular), and ash219 (which is a
+least-squares problem).  See cs_demo.out for the proper output of "make".

pytexgen-1.0.0/CSparse/Demo/cs_demo.c

@@ -0,0 +1,286 @@
+#include "cs_demo.h"
+#include <time.h>
+/* 1 if A is square & upper tri., -1 if square & lower tri., 0 otherwise */
+static int is_sym (cs *A)
+{
+    int is_upper, is_lower, j, p, n = A->n, m = A->m, *Ap = A->p, *Ai = A->i ;
+    if (m != n) return (0) ;
+    is_upper = 1 ;
+    is_lower = 1 ;
+    for (j = 0 ; j < n ; j++)
+    {
+	for (p = Ap [j] ; p < Ap [j+1] ; p++)
+	{
+	    if (Ai [p] > j) is_upper = 0 ;
+	    if (Ai [p] < j) is_lower = 0 ;
+	}
+    }
+    return (is_upper ? 1 : (is_lower ? -1 : 0)) ;
+}
+
+/* true for off-diagonal entries */
+static int dropdiag (int i, int j, double aij, void *other) { return (i != j) ;}
+
+/* C = A + triu(A,1)' */
+static cs *make_sym (cs *A)
+{
+    cs *AT, *C ;
+    AT = cs_transpose (A, 1) ;		/* AT = A' */
+    cs_fkeep (AT, &dropdiag, NULL) ;	/* drop diagonal entries from AT */
+    C = cs_add (A, AT, 1, 1) ;		/* C = A+AT */
+    cs_spfree (AT) ;
+    return (C) ;
+}
+
+/* create a right-hand side */
+static void rhs (double *x, double *b, int m)
+{
+    int i ;
+    for (i = 0 ; i < m ; i++) b [i] = 1 + ((double) i) / m ;
+    for (i = 0 ; i < m ; i++) x [i] = b [i] ;
+}
+
+/* infinity-norm of x */
+static double norm (double *x, int n)
+{
+    int i ;
+    double normx = 0 ;
+    for (i = 0 ; i < n ; i++) normx = CS_MAX (normx, fabs (x [i])) ;
+    return (normx) ;
+}
+
+/* compute residual, norm(A*x-b,inf) / (norm(A,1)*norm(x,inf) + norm(b,inf)) */
+static void print_resid (int ok, cs *A, double *x, double *b, double *resid)
+{
+    int i, m, n ;
+    if (!ok) { printf ("    (failed)\n") ; return ; }
+    m = A->m ; n = A->n ;
+    for (i = 0 ; i < m ; i++) resid [i] = -b [i] ;  /* resid = -b */
+    cs_gaxpy (A, x, resid) ;			    /* resid = resid + A*x  */
+    printf ("resid: %8.2e\n", norm (resid,m) / ((n == 0) ? 1 :
+	(cs_norm (A) * norm (x,n) + norm (b,m)))) ;
+}
+
+static double tic (void) { return (clock () / (double) CLOCKS_PER_SEC) ; }
+static double toc (double t) { double s = tic () ; return (CS_MAX (0, s-t)) ; }
+
+static void print_order (int order)
+{
+    switch (order)
+    {
+	case 0: printf ("natural    ") ; break ;
+	case 1: printf ("amd(A+A')  ") ; break ;
+	case 2: printf ("amd(S'*S)  ") ; break ;
+	case 3: printf ("amd(A'*A)  ") ; break ;
+    }
+}
+
+/* read a problem from a file */
+problem *get_problem (FILE *f, double tol)
+{
+    cs *T, *A, *C ;
+    int sym, m, n, mn, nz1, nz2 ;
+    problem *Prob ;
+    Prob = cs_calloc (1, sizeof (problem)) ;
+    if (!Prob) return (NULL) ;
+    T = cs_load (f) ;			/* load triplet matrix T from a file */
+    Prob->A = A = cs_compress (T) ;	/* A = compressed-column form of T */
+    cs_spfree (T) ;			/* clear T */
+    if (!cs_dupl (A)) return (free_problem (Prob)) ; /* sum up duplicates */
+    Prob->sym = sym = is_sym (A) ;	/* determine if A is symmetric */
+    m = A->m ; n = A->n ;
+    mn = CS_MAX (m,n) ;
+    nz1 = A->p [n] ;
+    cs_dropzeros (A) ;			/* drop zero entries */
+    nz2 = A->p [n] ;
+    if (tol > 0) cs_droptol (A, tol) ;	/* drop tiny entries (just to test) */
+    Prob->C = C = sym ? make_sym (A) : A ;  /* C = A + triu(A,1)', or C=A */
+    if (!C) return (free_problem (Prob)) ;
+    printf ("\n--- Matrix: %d-by-%d, nnz: %d (sym: %d: nnz %d), norm: %8.2e\n",
+	    m, n, A->p [n], sym, sym ? C->p [n] : 0, cs_norm (C)) ;
+    if (nz1 != nz2) printf ("zero entries dropped: %d\n", nz1 - nz2) ;
+    if (nz2 != A->p [n]) printf ("tiny entries dropped: %d\n", nz2 - A->p [n]) ;
+    Prob->b = cs_malloc (mn, sizeof (double)) ;
+    Prob->x = cs_malloc (mn, sizeof (double)) ;
+    Prob->resid = cs_malloc (mn, sizeof (double)) ;
+    return ((!Prob->b || !Prob->x || !Prob->resid) ? free_problem (Prob) : Prob) ;
+}
+
+/* free a problem */
+problem *free_problem (problem *Prob)
+{
+    if (!Prob) return (NULL) ;
+    cs_spfree (Prob->A) ;
+    if (Prob->sym) cs_spfree (Prob->C) ;
+    cs_free (Prob->b) ;
+    cs_free (Prob->x) ;
+    cs_free (Prob->resid) ;
+    return (cs_free (Prob)) ;
+}
+
+/* solve a linear system using Cholesky, LU, and QR, with various orderings */
+int demo2 (problem *Prob)
+{
+    cs *A, *C ;
+    double *b, *x, *resid,  t, tol ;
+    int k, m, n, ok, order, nb, ns, *r, *s, *rr, sprank ;
+    csd *D ;
+    if (!Prob) return (0) ;
+    A = Prob->A ; C = Prob->C ; b = Prob->b ; x = Prob->x ; resid = Prob->resid;
+    m = A->m ; n = A->n ;
+    tol = Prob->sym ? 0.001 : 1 ;		/* partial pivoting tolerance */
+    D = cs_dmperm (C, 1) ;			/* randomized dmperm analysis */
+    if (!D) return (0) ;
+    nb = D->nb ; r = D->r ; s = D->s ; rr = D->rr ;
+    sprank = rr [3] ;
+    for (ns = 0, k = 0 ; k < nb ; k++)
+    {
+	ns += ((r [k+1] == r [k]+1) && (s [k+1] == s [k]+1)) ;
+    }
+    printf ("blocks: %d singletons: %d structural rank: %d\n", nb, ns, sprank) ;
+    cs_dfree (D) ;
+    for (order = 0 ; order <= 3 ; order += 3)	/* natural and amd(A'*A) */
+    {
+	if (!order && m > 1000) continue ;
+	printf ("QR   ") ;
+	print_order (order) ;
+	rhs (x, b, m) ;				/* compute right-hand side */
+	t = tic () ;
+	ok = cs_qrsol (order, C, x) ;		/* min norm(Ax-b) with QR */
+	printf ("time: %8.2f ", toc (t)) ;
+	print_resid (ok, C, x, b, resid) ;	/* print residual */
+    }
+    if (m != n || sprank < n) return (1) ;	/* return if rect. or singular*/
+    for (order = 0 ; order <= 3 ; order++)	/* try all orderings */
+    {
+	if (!order && m > 1000) continue ;
+	printf ("LU   ") ;
+	print_order (order) ;
+	rhs (x, b, m) ;				/* compute right-hand side */
+	t = tic () ;
+	ok = cs_lusol (order, C, x, tol) ;	/* solve Ax=b with LU */
+	printf ("time: %8.2f ", toc (t)) ;
+	print_resid (ok, C, x, b, resid) ;	/* print residual */
+    }
+    if (!Prob->sym) return (1) ;
+    for (order = 0 ; order <= 1 ; order++)	/* natural and amd(A+A') */
+    {
+	if (!order && m > 1000) continue ;
+	printf ("Chol ") ;
+	print_order (order) ;
+	rhs (x, b, m) ;				/* compute right-hand side */
+	t = tic () ;
+	ok = cs_cholsol (order, C, x) ;		/* solve Ax=b with Cholesky */
+	printf ("time: %8.2f ", toc (t)) ;
+	print_resid (ok, C, x, b, resid) ;	/* print residual */
+    }
+    return (1) ;
+} 
+
+/* free workspace for demo3 */
+static int done3 (int ok, css *S, csn *N, double *y, cs *W, cs *E, int *p)
+{
+    cs_sfree (S) ;
+    cs_nfree (N) ;
+    cs_free (y) ;
+    cs_spfree (W) ;
+    cs_spfree (E) ;
+    cs_free (p) ;
+    return (ok) ;
+}
+
+/* Cholesky update/downdate */
+int demo3 (problem *Prob)
+{
+    cs *A, *C, *W = NULL, *WW, *WT, *E = NULL, *W2 ;
+    int n, k, *Li, *Lp, *Wi, *Wp, p1, p2, *p = NULL, ok ;
+    double *b, *x, *resid, *y = NULL, *Lx, *Wx, s,  t, t1 ;
+    css *S = NULL ;
+    csn *N = NULL ;
+    if (!Prob || !Prob->sym || Prob->A->n == 0) return (0) ;
+    A = Prob->A ; C = Prob->C ; b = Prob->b ; x = Prob->x ; resid = Prob->resid;
+    n = A->n ;
+    if (!Prob->sym || n == 0) return (1) ;
+    rhs (x, b, n) ;				/* compute right-hand side */
+    printf ("\nchol then update/downdate ") ;
+    print_order (1) ;
+    y = cs_malloc (n, sizeof (double)) ;
+    t = tic () ;
+    S = cs_schol (1, C) ;			/* symbolic Chol, amd(A+A') */
+    printf ("\nsymbolic chol time %8.2f\n", toc (t)) ;
+    t = tic () ;
+    N = cs_chol (C, S) ;			/* numeric Cholesky */
+    printf ("numeric  chol time %8.2f\n", toc (t)) ;
+    if (!S || !N || !y) return (done3 (0, S, N, y, W, E, p)) ;
+    t = tic () ;
+    cs_ipvec (S->pinv, b, y, n) ;		/* y = P*b */
+    cs_lsolve (N->L, y) ;			/* y = L\y */
+    cs_ltsolve (N->L, y) ;			/* y = L'\y */
+    cs_pvec (S->pinv, y, x, n) ;		/* x = P'*y */
+    printf ("solve    chol time %8.2f\n", toc (t)) ;
+    printf ("original: ") ;
+    print_resid (1, C, x, b, resid) ;		/* print residual */
+    k = n/2 ;					/* construct W  */
+    W = cs_spalloc (n, 1, n, 1, 0) ;
+    if (!W) return (done3 (0, S, N, y, W, E, p)) ;
+    Lp = N->L->p ; Li = N->L->i ; Lx = N->L->x ;
+    Wp = W->p ; Wi = W->i ; Wx = W->x ;
+    Wp [0] = 0 ;
+    p1 = Lp [k] ;
+    Wp [1] = Lp [k+1] - p1 ;
+    s = Lx [p1] ;
+    srand (1) ;
+    for ( ; p1 < Lp [k+1] ; p1++)
+    {
+	p2 = p1 - Lp [k] ;
+	Wi [p2] = Li [p1] ;
+	Wx [p2] = s * rand () / ((double) RAND_MAX) ;
+    }
+    t = tic () ;
+    ok = cs_updown (N->L, +1, W, S->parent) ;	/* update: L*L'+W*W' */
+    t1 = toc (t) ;
+    printf ("update:   time: %8.2f\n", t1) ;
+    if (!ok) return (done3 (0, S, N, y, W, E, p)) ;
+    t = tic () ;
+    cs_ipvec (S->pinv, b, y, n) ;		/* y = P*b */
+    cs_lsolve (N->L, y) ;			/* y = L\y */
+    cs_ltsolve (N->L, y) ;			/* y = L'\y */
+    cs_pvec (S->pinv, y, x, n) ;		/* x = P'*y */
+    t = toc (t) ;
+    p = cs_pinv (S->pinv, n) ;
+    W2 = cs_permute (W, p, NULL, 1) ;		/* E = C + (P'W)*(P'W)' */
+    WT = cs_transpose (W2,1) ;
+    WW = cs_multiply (W2, WT) ;
+    cs_spfree (WT) ;
+    cs_spfree (W2) ;
+    E = cs_add (C, WW, 1, 1) ;
+    cs_spfree (WW) ;
+    if (!E || !p) return (done3 (0, S, N, y, W, E, p)) ;
+    printf ("update:   time: %8.2f (incl solve) ", t1+t) ;
+    print_resid (1, E, x, b, resid) ;		/* print residual */
+    cs_nfree (N) ;				/* clear N */
+    t = tic () ;
+    N = cs_chol (E, S) ;			/* numeric Cholesky */
+    if (!N) return (done3 (0, S, N, y, W, E, p)) ;
+    cs_ipvec (S->pinv, b, y, n) ;		/* y = P*b */
+    cs_lsolve (N->L, y) ;			/* y = L\y */
+    cs_ltsolve (N->L, y) ;			/* y = L'\y */
+    cs_pvec (S->pinv, y, x, n) ;		/* x = P'*y */
+    t = toc (t) ;
+    printf ("rechol:   time: %8.2f (incl solve) ", t) ;
+    print_resid (1, E, x, b, resid) ;		/* print residual */
+    t = tic () ;
+    ok = cs_updown (N->L, -1, W, S->parent) ;	/* downdate: L*L'-W*W' */
+    t1 = toc (t) ;
+    if (!ok) return (done3 (0, S, N, y, W, E, p)) ;
+    printf ("downdate: time: %8.2f\n", t1) ;
+    t = tic () ;
+    cs_ipvec (S->pinv, b, y, n) ;		/* y = P*b */
+    cs_lsolve (N->L, y) ;			/* y = L\y */
+    cs_ltsolve (N->L, y) ;			/* y = L'\y */
+    cs_pvec (S->pinv, y, x, n) ;		/* x = P'*y */
+    t = toc (t) ;
+    printf ("downdate: time: %8.2f (incl solve) ", t1+t) ;
+    print_resid (1, C, x, b, resid) ;		/* print residual */
+    return (done3 (1, S, N, y, W, E, p)) ;
+} 

pytexgen-1.0.0/CSparse/Demo/cs_demo.h

@@ -0,0 +1,15 @@
+#include "cs.h"
+typedef struct problem_struct
+{
+    cs *A ;
+    cs *C ;
+    int sym ;
+    double *x ;
+    double *b ;
+    double *resid ;
+} problem ;
+
+problem *get_problem (FILE *f, double tol) ;
+int demo2 (problem *Prob) ;
+int demo3 (problem *Prob) ;
+problem *free_problem (problem *Prob) ;

pytexgen-1.0.0/CSparse/Demo/cs_demo.out

@@ -0,0 +1,170 @@
+./cs_demo1 < ../Matrix/t1
+T:
+CSparse Version 2.2.0, Mar 31, 2007.  Copyright (c) Timothy A. Davis, 2006-2007
+triplet: 4-by-4, nzmax: 16 nnz: 10
+    2 2 : 3
+    1 0 : 3.1
+    3 3 : 1
+    0 2 : 3.2
+    1 1 : 2.9
+    3 0 : 3.5
+    3 1 : 0.4
+    1 3 : 0.9
+    0 0 : 4.5
+    2 1 : 1.7
+A:
+CSparse Version 2.2.0, Mar 31, 2007.  Copyright (c) Timothy A. Davis, 2006-2007
+4-by-4, nzmax: 10 nnz: 10, 1-norm: 11.1
+    col 0 : locations 0 to 2
+      1 : 3.1
+      3 : 3.5
+      0 : 4.5
+    col 1 : locations 3 to 5
+      1 : 2.9
+      3 : 0.4
+      2 : 1.7
+    col 2 : locations 6 to 7
+      2 : 3
+      0 : 3.2
+    col 3 : locations 8 to 9
+      3 : 1
+      1 : 0.9
+AT:
+CSparse Version 2.2.0, Mar 31, 2007.  Copyright (c) Timothy A. Davis, 2006-2007
+4-by-4, nzmax: 10 nnz: 10, 1-norm: 7.7
+    col 0 : locations 0 to 1
+      0 : 4.5
+      2 : 3.2
+    col 1 : locations 2 to 4
+      0 : 3.1
+      1 : 2.9
+      3 : 0.9
+    col 2 : locations 5 to 6
+      1 : 1.7
+      2 : 3
+    col 3 : locations 7 to 9
+      0 : 3.5
+      1 : 0.4
+      3 : 1
+D:
+CSparse Version 2.2.0, Mar 31, 2007.  Copyright (c) Timothy A. Davis, 2006-2007
+4-by-4, nzmax: 16 nnz: 16, 1-norm: 139.58
+    col 0 : locations 0 to 3
+      1 : 13.95
+      3 : 15.75
+      0 : 100.28
+      2 : 9.6
+    col 1 : locations 4 to 7
+      1 : 88.62
+      3 : 12.91
+      0 : 13.95
+      2 : 4.93
+    col 2 : locations 8 to 11
+      1 : 4.93
+      3 : 0.68
+      2 : 81.68
+      0 : 9.6
+    col 3 : locations 12 to 15
+      1 : 12.91
+      3 : 83.2
+      0 : 15.75
+      2 : 0.68
+./cs_demo2 < ../Matrix/t1
+
+--- Matrix: 4-by-4, nnz: 10 (sym: 0: nnz 0), norm: 1.11e+01
+blocks: 1 singletons: 0 structural rank: 4
+QR   natural    time:     0.00 resid: 1.53e-17
+QR   amd(A'*A)  time:     0.00 resid: 1.53e-17
+LU   natural    time:     0.00 resid: 1.04e-17
+LU   amd(A+A')  time:     0.00 resid: 4.94e-18
+LU   amd(S'*S)  time:     0.00 resid: 4.94e-18
+LU   amd(A'*A)  time:     0.00 resid: 4.94e-18
+./cs_demo2 < ../Matrix/ash219
+
+--- Matrix: 219-by-85, nnz: 438 (sym: 0: nnz 0), norm: 9.00e+00
+blocks: 1 singletons: 0 structural rank: 85
+QR   natural    time:     0.00 resid: 1.61e-02
+QR   amd(A'*A)  time:     0.00 resid: 1.61e-02
+./cs_demo2 < ../Matrix/bcsstk01
+
+--- Matrix: 48-by-48, nnz: 224 (sym: -1: nnz 400), norm: 3.57e+09
+blocks: 1 singletons: 0 structural rank: 48
+QR   natural    time:     0.00 resid: 2.83e-19
+QR   amd(A'*A)  time:     0.00 resid: 5.19e-19
+LU   natural    time:     0.00 resid: 2.63e-19
+LU   amd(A+A')  time:     0.00 resid: 8.63e-20
+LU   amd(S'*S)  time:     0.00 resid: 2.04e-19
+LU   amd(A'*A)  time:     0.00 resid: 2.04e-19
+Chol natural    time:     0.00 resid: 1.90e-19
+Chol amd(A+A')  time:     0.00 resid: 2.01e-19
+./cs_demo2 < ../Matrix/fs_183_1
+
+--- Matrix: 183-by-183, nnz: 988 (sym: 0: nnz 0), norm: 1.70e+09
+zero entries dropped: 71
+tiny entries dropped: 10
+blocks: 38 singletons: 37 structural rank: 183
+QR   natural    time:     0.00 resid: 1.09e-27
+QR   amd(A'*A)  time:     0.01 resid: 5.34e-28
+LU   natural    time:     0.00 resid: 3.08e-28
+LU   amd(A+A')  time:     0.00 resid: 1.42e-27
+LU   amd(S'*S)  time:     0.01 resid: 7.11e-28
+LU   amd(A'*A)  time:     0.00 resid: 7.11e-28
+./cs_demo2 < ../Matrix/mbeacxc
+
+--- Matrix: 492-by-490, nnz: 49920 (sym: 0: nnz 0), norm: 9.29e-01
+blocks: 10 singletons: 8 structural rank: 448
+QR   natural    time:     0.24 resid:      nan
+QR   amd(A'*A)  time:     0.30 resid:      nan
+./cs_demo2 < ../Matrix/west0067
+
+--- Matrix: 67-by-67, nnz: 294 (sym: 0: nnz 0), norm: 6.14e+00
+blocks: 2 singletons: 1 structural rank: 67
+QR   natural    time:     0.00 resid: 3.42e-17
+QR   amd(A'*A)  time:     0.00 resid: 1.95e-17
+LU   natural    time:     0.00 resid: 3.85e-17
+LU   amd(A+A')  time:     0.00 resid: 1.95e-17
+LU   amd(S'*S)  time:     0.00 resid: 2.60e-17
+LU   amd(A'*A)  time:     0.00 resid: 2.60e-17
+./cs_demo2 < ../Matrix/lp_afiro
+
+--- Matrix: 27-by-51, nnz: 102 (sym: 0: nnz 0), norm: 3.43e+00
+blocks: 1 singletons: 0 structural rank: 27
+QR   natural    time:     0.00 resid: 9.54e-17
+QR   amd(A'*A)  time:     0.00 resid: 1.89e-16
+./cs_demo2 < ../Matrix/bcsstk16
+
+--- Matrix: 4884-by-4884, nnz: 147631 (sym: -1: nnz 290378), norm: 7.01e+09
+blocks: 75 singletons: 74 structural rank: 4884
+QR   amd(A'*A)  time:     2.36 resid: 2.02e-22
+LU   amd(A+A')  time:     1.41 resid: 1.06e-22
+LU   amd(S'*S)  time:     1.38 resid: 1.21e-22
+LU   amd(A'*A)  time:     1.46 resid: 1.70e-22
+Chol amd(A+A')  time:     0.64 resid: 9.28e-23
+./cs_demo3 < ../Matrix/bcsstk01
+
+--- Matrix: 48-by-48, nnz: 224 (sym: -1: nnz 400), norm: 3.57e+09
+
+chol then update/downdate amd(A+A')  
+symbolic chol time     0.00
+numeric  chol time     0.00
+solve    chol time     0.00
+original: resid: 2.01e-19
+update:   time:     0.00
+update:   time:     0.00 (incl solve) resid: 8.39e-19
+rechol:   time:     0.00 (incl solve) resid: 1.20e-18
+downdate: time:     0.00
+downdate: time:     0.00 (incl solve) resid: 3.30e-17
+./cs_demo3 < ../Matrix/bcsstk16
+
+--- Matrix: 4884-by-4884, nnz: 147631 (sym: -1: nnz 290378), norm: 7.01e+09
+
+chol then update/downdate amd(A+A')  
+symbolic chol time     0.04
+numeric  chol time     0.59
+solve    chol time     0.02
+original: resid: 9.28e-23
+update:   time:     0.00
+update:   time:     0.01 (incl solve) resid: 8.62e-24
+rechol:   time:     0.61 (incl solve) resid: 8.72e-24
+downdate: time:     0.00
+downdate: time:     0.01 (incl solve) resid: 3.60e-22

pytexgen-1.0.0/CSparse/Demo/cs_demo1.c

@@ -0,0 +1,27 @@
+#include "cs.h"
+int main (void)
+{
+    cs *T, *A, *Eye, *AT, *C, *D ;
+    int i, m ;
+    T = cs_load (stdin) ;		/* load triplet matrix T from stdin */
+    printf ("T:\n") ; cs_print (T, 0) ;	/* print T */
+    A = cs_compress (T) ;		/* A = compressed-column form of T */
+    printf ("A:\n") ; cs_print (A, 0) ;	/* print A */
+    cs_spfree (T) ;			/* clear T */
+    AT = cs_transpose (A, 1) ;		/* AT = A' */
+    printf ("AT:\n") ; cs_print (AT, 0) ; /* print AT */
+    m = A ? A->m : 0 ;			/* m = # of rows of A */
+    T = cs_spalloc (m, m, m, 1, 1) ;	/* create triplet identity matrix */
+    for (i = 0 ; i < m ; i++) cs_entry (T, i, i, 1) ;
+    Eye = cs_compress (T) ;		/* Eye = speye (m) */
+    cs_spfree (T) ;
+    C = cs_multiply (A, AT) ;		/* C = A*A' */
+    D = cs_add (C, Eye, 1, cs_norm (C)) ;   /* D = C + Eye*norm (C,1) */
+    printf ("D:\n") ; cs_print (D, 0) ;	/* print D */
+    cs_spfree (A) ;			/* clear A AT C D Eye */
+    cs_spfree (AT) ;
+    cs_spfree (C) ;
+    cs_spfree (D) ;
+    cs_spfree (Eye) ;
+    return (0) ;
+}

pytexgen-1.0.0/CSparse/Demo/cs_demo2.c

@@ -0,0 +1,9 @@
+#include "cs_demo.h"
+/* cs_demo2: read a matrix and solve a linear system */
+int main (void)
+{
+    problem *Prob = get_problem (stdin, 1e-14) ;
+    demo2 (Prob) ;
+    free_problem (Prob) ;
+    return (0) ;
+}