Mec-iS

"The Emerging Field of Signal Processing on Graphs: Extending High-Dimensional Data Analysis to Networks and Other Irregular Domains"

Authors: David I. Shuman, Sunil K. Narang, Pascal Frossard, Antonio Ortega, Pierre Vandergheynst Published: IEEE Signal Processing Magazine, 2013 (originally arXiv:1211.0053, 2012)

Overview

This seminal tutorial paper introduces Graph Signal Processing (GSP), a field that extends classical digital signal processing techniques to data residing on irregular graph structures. The work addresses the fundamental challenge of processing high-dimensional data in applications where information naturally exists on graph vertices rather than regular grids.

Key Motivations

Mec-iS

how to solve missing dll for clang when trying to compile Rust code on windows

Resolving Missing DLL Errors for Clang During Rust Compilation on Windows

When compiling Rust projects that depend on Clang tooling (e.g., via bindgen), Windows users frequently encounter errors related to missing DLLs such as libclang.dll, libLLVMX86Desc.dll, or similar. These issues stem from environmental misconfigurations, security software interference, or architectural incompatibilities. This report synthesizes solutions from empirical developer experiences and toolchain documentation to provide a systematic approach to diagnosing and resolving these errors.

Common Causes of Missing DLL Errors

1. Antivirus or Windows Security Quarantining DLLs

Windows Defender and third-party antivirus tools may falsely flag Clang/LLVM DLLs as malicious and quarantine or delete them. For example, libLLVMX86Desc.dll has been reported as erroneously detected as a Trojan[1]. This results in immediate errors when

Mec-iS

use std::collections::HashMap;
use std::net::{TcpListener, TcpStream};
use std::os::unix::io::AsRawFd;
use nix::sys::socket::{setsockopt, sockopt::Nonblock};
use nix::poll::{poll, PollFd, EventFlags};

const STATE_REQ: u32 = 0;
const STATE_RES: u32 = 1;
const STATE_END: u32 = 2;

Mec-iS

package main

import(
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "time"
)

Mec-iS

Mec-iS

# -*- coding: utf-8 -*-
__doc__ = """Fast hierarchical clustering routines for R and Python

Copyright © 2011 Daniel Müllner
<http://math.stanford.edu/~muellner>

This module provides fast hierarchical clustering routines. The "linkage"
method is designed to provide a replacement for the “linkage” function and
its siblings in the scipy.cluster.hierarchy module. You may use the methods
in this module with the same syntax as the corresponding SciPy functions but

Mec-iS

Definition of Truth

Jason the Goodman <jasonthegoodman@....com>:

How about defining "truth" with "stability" of the coupling loop between "the object" and the cognitive system coupling with the "object"? If the process stabilizes and an eigenvalue of the loop emerges, we say "a truth" is found. This would refocus our attention from the "object" itself to the nature of the cognitive system, which may include animals and robots in addition to humans. My tentative way to upgrade from first-order thinking to the second-order thinking. Then, instead of searching for "truth", we search for the "Lyapunov potential function" for the situation if we could find one...

Louis H Kauffman <kauffman@....edu>

Eigenform is important way to formalize a kind of stability. Truth is a special kind of eigenform, not just any eigenform. Truth means the truth of a PROPOSITION about something. So we need to have a language involved and the notion that the propositions are talking about some domain where it is possible to c

Mec-iS

Ideas for python-ext-wasmer

Guideines to adoption/contribution

• Read the Instance.rs documentation to understand how WASM binaries are ported to Python modules via pyo3 Rust crate.
• Simply put the workflow looks something like:

1. Developer defines Rust functions and compile them via wasm32-unknown-unknown target
2. WASM binary (.wasm) is placed in a Python project
3. With the tools imported via pip install wasmer, developer can load the WASM binary and use the exported functions. This way Rust-defined functions can be called transparently from Python. Great Wasmer!

Ideas for a stable interface

Mec-iS

fn Merge(c: Vec<i32>, d: Vec<i32>) -> Vec<i32> {
    let l: usize = c.len() + d.len();

    // initialize result array
    let mut b: Vec<i32> = vec!(0; l);

    // initialize readers indexes
    let mut i: usize = 0;
    let mut j: usize = 0;

Mec-iS

/// Taken from "Programming Rust" by Jim Blandy and Jason Orendorff

// Expressions that don’t finish normally are assigned the special type ! ,
// and they’re exempt from the rules about types having to match.
// You can see ! in the function signature of `std::process::exit()`:
fn exit(code: i32) -> !

// The ! means that exit() never returns. It’s a divergent function.
// You can write divergent functions of your own using the same syntax,
// and this is perfectly natural in some cases: