rob-p

rob-p

#ifndef STREAMING_QUERY_HPP
#define STREAMING_QUERY_HPP

#include "../external/pthash/external/essentials/include/essentials.hpp"
#include "../include/dictionary.hpp"
#include "../include/query/streaming_query_canonical_parsing.hpp"
#include "../include/util.hpp"
#include <sstream>

namespace piscem {

rob-p

fn create_record(line: &str) -> Record {
    let finder = memchr::memmem::Finder::new("bc");
    let mut iter = line.split('\t').peekable();
    let name = iter.peek().unwrap().to_string();
    let count = iter
        .filter(|s| finder.find(s[1..4].as_bytes()).is_some())
        .count();
    Record::new(name, count)
}

rob-p

#!/bin/bash
#
# This is a rather minimal example Argbash potential
# Example taken from http://argbash.readthedocs.io/en/stable/example.html
#
# ARG_OPTIONAL_BOOLEAN([delete-tmp],[],[delete output directory])
# ARG_POSITIONAL_SINGLE([num-threads],[number of threads to run with],[])
# ARG_POSITIONAL_SINGLE([input],[input file list],[])
# ARG_HELP([Test how long it takes to decompress many files in parallel])
# ARGBASH_GO()

rob-p

use anyhow;
use ndarray::Array2;
use std::fs;
use std::cmp::Ordering;

fn naive_table(text: &str) -> Vec<u32> {
    let text = text.as_bytes();
    assert!(text.len() <= u32::MAX as usize);
    let mut table = vec![0u32; text.len()];
    for (i, element) in table.iter_mut().enumerate() {

rob-p

$ uname -a
Linux fern 6.2.0-33-generic #33~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Thu Sep  7 10:33:52 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

zcat

$ zcat data/20201028_CCDG_14151_B01_GRM_WGS_2020-08-05_chr21.recalibrated_variants.vcf.gz|head -c $(( 10 * 1024 * 1024 * 1024 )) | pv >/dev/null
10.0GiB 0:00:47 [ 216MiB/s] [                                                                                                                                                           <=>       ]

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) {