Tao He sighingnow

Tricks in Modern C++

is_specialization_of

Whether the type is a specialization of template T.

template  class T, typename U&gt;

Build LLVM/Clang Docset

Modify LLVM/Clang doxygen.config.in
- GENERATE_DOCSET = YES
- DISABLE_INDEX = YES
- SEARCHENGINE = NO
- GENERATE_TREEVIEW = NO
- GENERATE_TAGFILE =

LLVM: @abs_top_builddir@/doxygen/llvm(clang).tag

ffmpeg

Converting Audio into Different Formats / Sample Rates

Minimal example: transcode from MP3 to WMA:
ffmpeg -i input.mp3 output.wma

You can get the list of supported formats with:
ffmpeg -formats

Convert WAV to MP3, mix down to mono (use 1 audio channel), set bit rate to 64 kbps and sample rate to 22050 Hz:

Why COW was deemed ungood for std::string.

COW, short for copy on write, is a way to implement mutable strings so that creating strings and logically copying strings, is reduced to almost nothing; conceptually they become free operations like no-ops.

Basic idea: to share a data buffer among string instances, and only make a copy for a specific instance (the copy on write) when that instance's data is modified. The general cost of this is only an extra indirection for accessing the value of a string, so a COW implementation is highly desirable. And so the original C++ standard, C++98, and its correction C++03, had special support for COW implementations, and e.g. the g++ compiler's std::string implementations used COW.

So why was that support dropped in C++11?

In particular, would the same reason or reasons apply to a reference counted immutable string value class?

	"""Simple example on how to log scalars and images to tensorboard without tensor ops.

	License: Copyleft
	"""
	__author__ = "Michael Gygli, Tao He"

	import tensorflow as tf
	try:
	from StringIO import StringIO
	except:

	D:\Open>gcc test.c -Wall -c
	test.c: In function 'g':
	test.c:8:14: warning: passing argument 1 of 'f' from incompatible pointer type [-Wincompatible-pointer-types]
	return f(cp);
	^~
	test.c:1:5: note: expected 'int ' but argument is of type 'char '
	int f(int *a) {
	^

	D:\Open>stack exec -- ghc -c test.c -Wall

	{-# LANGUAGE BangPatterns #-}

	import Criterion.Main
	import Weigh

	numericEnumFromThen :: (Fractional a) => a -> a -> [a]
	numericEnumFromThen n m = n `seq` m `seq` (n : numericEnumFromThen m (m+m-n))

	numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
	numericEnumFromThenTo e1 e2 e3

	#!/usr/bin/env python3
	# -- coding: utf-8 --

	import gc


	def list_live_objects(ty=None):
	def go(results, elements, bitset):
	for elem in elements:
	identity = id(elem)

	use std::env;

	use nix::sched;
	use nix::sched::CloneFlags;
	use nix::sys::signal::Signal;
	use nix::sys::wait::waitpid;
	use nix::unistd;
	use cgroups_rs as cgroup;
	use cgroups_rs::{Cgroup};
	use cgroups_rs::cgroup_builder::{CgroupBuilder};

	use std;
	use std::env;
	use std::fs;
	use std::io::Write;

	use nix::mount;
	use nix::sched;
	use nix::sched::CloneFlags;
	use nix::sys::signal::Signal;
	use nix::sys::wait::waitpid;