rob-p

#[macro_use]
extern crate derive_builder;

#[derive(Default, Builder, Debug)]
#[builder(setter(into))]
struct House {
    floors: u32,
    rooms: u32,
    #[builder(default = "false")]
    has_garage: bool,

rob-p

Note: This is cross-posted from reddit.

I've been trying to determine (a) if it's possible to achieve something in rust and (b) if so, how. I will try to abstract the problem as much as possible since the details of this in my code are rather boring and unessential to describe the problem.

I have a program that extracts information from the combination of a polars data frame, and a paired file. This is for a genomics application, and for those interested, the data frame contains the locations of sequence features (exons, transcripts, etc.) and the file contains the genome sequence (chromosome by chromosome). The genome is large, so we prefer not to load the whole thing in memory, and instead to iterate over it chromosome by chromosome and then feature by feature, yielding each sequence feature one at a time.

It turns out it's relatively simple to write a "single sequence" iterator (i.e. an iterato

rob-p

use antisequence::*;

fn main() {
    // 1{b[9-10]f[CAGAGC]u[8]b[10]}2{r:}
    let patterns = r#"
        name: anchor 
        patterns:
            - pattern: "CAGAGC"
    "#;

rob-p

#include <immintrin.h>

const char* longest_common_prefix(const char* str1, const char* str2, int len) {
    int i = 0;
    for (; i <= len - 32; i += 32) {
        __m256i v1 = _mm256_loadu_si256((__m256i*)(str1 + i));
        __m256i v2 = _mm256_loadu_si256((__m256i*)(str2 + i));
        __m256i cmp = _mm256_cmpeq_epi8(v1, v2);
        int mask = _mm256_movemask_epi8(cmp);
        if (mask != 0xFFFFFFFF) {

rob-p

#include <immintrin.h> // for AVX2 intrinsics
#include <cstring> // for strlen

size_t longestCommonPrefixAVX2(const char* str1, const char* str2) {
    const size_t len1 = strlen(str1);
    const size_t len2 = strlen(str2);
    const size_t len = std::min(len1, len2);

    const __m256i* p1 = reinterpret_cast<const __m256i*>(str1);
    const __m256i* p2 = reinterpret_cast<const __m256i*>(str2);

rob-p

from pafpy import PafFile
import argparse
import sys

def parse_tab6(tf):
	res = []
	first = True
	with open(tf, 'r') as ifile:
		for l in ifile:
			if first:

rob-p

from pafpy import PafFile
import argparse
import sys

def main(args):
    pi = args.input
    of = args.out

    ld = {}
    with open(args.lens, 'r') as ifile:

rob-p

from pafpy import PafFile
import argparse
import sys


def main(argsj):
    pi = args.paf
    of = args.tblast

    def frac_covered(r):

rob-p

nextflow.enable.dsl=2

process foo {
    publishDir "output"

    input:
    val(prefix)

    output:
    path "${prefix}_foo"

rob-p

from math import *

# function [alpha, xmin, L]=plfit(x, varargin)
# PLFIT fits a power-law distributional model to data.
#    Source: http://www.santafe.edu/~aaronc/powerlaws/
# 
#    PLFIT(x) estimates x_min and alpha according to the goodness-of-fit
#    based method described in Clauset, Shalizi, Newman (2007). x is a 
#    vector of observations of some quantity to which we wish to fit the 
#    power-law distribution p(x) ~  x^-alpha for x >= xmin.