365ocs-0001index.xmlOwenowensmithfalseI am a Sr. Scientific Software Developer for NASA Goddard's Earth Sciences Data Information Services Center and a Ph.D. Candidate in Geospatial Analytics @ NCSU. You can also find me elsewhere at bsky, sourcehut, github.This website is built using Forester and is used to collect various notes. You can search the site using ctrl+k364ocs-0002ocs-0002.xmlNotesThis is a notebook in which I keep notes of a variety of subjects at varying degrees of disjointedness.249ocs-0006ocs-0006.xmlDouble Logistic Greendown ModelNote2025320Logistic sigmoid function for modeling Phenology detailed in Elmore et. al 2011 & Gao et al. 2011. The function combines spring and autumn seasons into a single equation to account for the greendown phenomena by allowing for a gradual reduction of VI values in mid-summer. Typically the model is fit to all VI observations within a single year using maximum likelihood methods. where is the modeled VI value at time in terms of day of year (DOY) is a parameter vector controlling the shape of the double-logistic function. represents the mean VI value in the dormant period; represents the difference between VI value at time and the dormant mean; and are the inflection points that are commonly used to represent start-of-season (SOS) and end-of-season (EOS) dates in terms of DOY in the spring and autumn; and are the corresponding slopes of the VI trajectories in spring and autumn; is the “greendown” parameter that accounts for the VI greendown phenomenon in the mid-summer time.Given the set and , a single years phenology would be estimated by the following curve. {} m m}{ \path coordinate (#1nw) ++(#2,-#3) coordinate (#1se) coordinate (#1sw) at (#1se -| #1nw) coordinate (#1ne) at (#1nw -| #1se) ; \path[spath/save = #1north] (#1nw) to (#1ne); \path[spath/save = #1west] (#1nw) to (#1sw); \path[spath/save = #1east] (#1ne) to (#1se); \path[spath/save = #1south] (#1sw) to (#1se); } \usepackage{tikz, tikz-cd, mathtools, amssymb, stmaryrd} \usepackage{pgfplots} \usepackage{amsmath} \usetikzlibrary{matrix,arrows, patterns} \usetikzlibrary{backgrounds,fit,positioning,calc,shapes} \usetikzlibrary{decorations.pathreplacing} \usetikzlibrary{decorations.pathmorphing} \usetikzlibrary{decorations.markings} \tikzset{ desc/.style={sloped, fill=white,inner sep=2pt}, upright desc/.style={fill=white,inner sep=2pt}, pullback/.style = { append after command={ \pgfextra{ \draw ($(\tikzlastnode) + (.2cm,-.5cm)$) -- ++(0.3cm,0) -- ++(0,0.3cm); } } }, pullback 45/.style = { append after command={ \pgfextra{ \draw[rotate = 45] ($(\tikzlastnode) + (.2cm,-.5cm)$) -- ++(0.3cm,0) -- ++(0,0.3cm); } } }, ne pullback/.style = { append after command={ \pgfextra{ \draw ($(\tikzlastnode) + (-.2cm,-.5cm)$) -- ++(-0.3cm,0) -- ++(0,0.3cm); } } }, sw pullback/.style = { append after command={ \pgfextra{ \draw ($(\tikzlastnode) + (.2cm,.5cm)$) -- ++(0.3cm,0) -- ++(0,-0.3cm); } } }, dotted pullback/.style = { append after command={ \pgfextra{ \draw [densely dotted] ($(\tikzlastnode) + (.2cm,-.5cm)$) -- ++(0.3cm,0) -- ++(0,0.3cm); } } }, muted pullback/.style = { append after command={ \pgfextra{ \draw [gray] ($(\tikzlastnode) + (.2cm,-.5cm)$) -- ++(0.3cm,0) -- ++(0,0.3cm); } } }, pushout/.style = { append after command={ \pgfextra{ \draw ($(\tikzlastnode) + (-.2cm,.5cm)$) -- ++(-0.3cm,0) -- ++(0,-0.3cm); } } }, between/.style args={#1 and #2}{ at = ($(#1)!0.5!(#2)$) }, diagram/.style = { on grid, node distance=2cm, commutative diagrams/every diagram, line width = .5pt, every node/.append style = { commutative diagrams/every cell, } }, fibration/.style = { -{Triangle[open]} }, etale/.style = { -{Triangle[open]} }, etale cover/.style= { >={Triangle[open]},->.> }, opfibration/.style = { -{Triangle} }, lies over/.style = { |-{Triangle[open]} }, op lies over/.style = { |-{Triangle} }, embedding/.style = { {right hook}-> }, open immersion/.style = { {right hook}-{Triangle[open]} }, closed immersion/.style = { {right hook}-{Triangle} }, closed immersion*/.style = { {left hook}-{Triangle} }, embedding*/.style = { {left hook}-> }, open immersion*/.style = { {left hook}-{Triangle[open]} }, exists/.style = { densely dashed }, } \newlength{\dontworryaboutit} \tikzset{ inline diagram/.style = { commutative diagrams/every diagram, commutative diagrams/cramped, line width = .5pt, every node/.append style = { commutative diagrams/every cell, anchor = base, inner sep = 0pt }, every path/.append style = { outer xsep = 2pt } } } \tikzset{ square/nw/.style = {}, square/ne/.style = {}, square/se/.style = {}, square/sw/.style = {}, square/north/.style = {->}, square/south/.style = {->}, square/west/.style = {->}, square/east/.style = {->}, square/north/node/.style = {above}, square/south/node/.style = {below}, square/west/node/.style = {left}, square/east/node/.style = {right}, } \ExplSyntaxOn \bool_new:N \l_jon_glue_west \keys_define:nn { jon-tikz/diagram } { nw .tl_set:N = \l_jon_tikz_diagram_nw, sw .tl_set:N = \l_jon_tikz_diagram_sw, ne .tl_set:N = \l_jon_tikz_diagram_ne, se .tl_set:N = \l_jon_tikz_diagram_se, width .tl_set:N = \l_jon_tikz_diagram_width, height .tl_set:N = \l_jon_tikz_diagram_height, north .tl_set:N = \l_jon_tikz_diagram_north, south .tl_set:N = \l_jon_tikz_diagram_south, west .tl_set:N = \l_jon_tikz_diagram_west, east .tl_set:N = \l_jon_tikz_diagram_east, nw/style .code:n = {\tikzset{square/nw/.style = {#1}}}, sw/style .code:n = {\tikzset{square/sw/.style = {#1}}}, ne/style .code:n = {\tikzset{square/ne/.style = {#1}}}, se/style .code:n = {\tikzset{square/se/.style = {#1}}}, glue .choice:, glue / west .code:n = {\bool_set:Nn \l_jon_glue_west \c_true_bool}, glue~target .tl_set:N = \l_jon_tikz_glue_target, north/style .code:n = {\tikzset{square/north/.style = {#1}}}, north/node/style .code:n = {\tikzset{square/north/node/.style = {#1}}}, south/style .code:n = {\tikzset{square/south/.style = {#1}}}, south/node/style .code:n = {\tikzset{square/south/node/.style = {#1}}}, west/style .code:n = {\tikzset{square/west/.style = {#1}}}, west/node/style .code:n = {\tikzset{square/west/node/.style = {#1}}}, east/style .code:n = {\tikzset{square/east/.style = {#1}}}, east/node/style .code:n = {\tikzset{square/east/node/.style = {#1}}}, draft .meta:n = { nw = {\__jon_tikz_diagram_fmt_placeholder:n {nw}}, sw = {\__jon_tikz_diagram_fmt_placeholder:n {sw}}, se = {\__jon_tikz_diagram_fmt_placeholder:n {se}}, ne = {\__jon_tikz_diagram_fmt_placeholder:n {ne}}, north = {\__jon_tikz_diagram_fmt_placeholder:n {north}}, south = {\__jon_tikz_diagram_fmt_placeholder:n {south}}, west = {\__jon_tikz_diagram_fmt_placeholder:n {west}}, east = {\__jon_tikz_diagram_fmt_placeholder:n {east}}, } } \tl_set:Nn \l_jon_tikz_diagram_width { 2cm } \tl_set:Nn \l_jon_tikz_diagram_height { 2cm } \cs_new:Npn \__jon_tikz_diagram_fmt_placeholder:n #1 { \texttt{\textcolor{red}{#1}} } \keys_set:nn { jon-tikz/diagram } { glue~target = {}, } \cs_new:Nn \__jon_tikz_render_square:nn { \group_begin: \keys_set:nn {jon-tikz/diagram} {#2} \bool_if:nTF \l_jon_glue_west { \node (#1ne) [right = \l_jon_tikz_diagram_width~of~\l_jon_tikz_glue_target ne,square/ne] {$\l_jon_tikz_diagram_ne$}; \node (#1se) [below = \l_jon_tikz_diagram_height~of~#1ne,square/se] {$\l_jon_tikz_diagram_se$}; \draw[square/north] (\l_jon_tikz_glue_target ne) to node [square/north/node] {$\l_jon_tikz_diagram_north$} (#1ne); \draw[square/east] (#1ne) to node [square/east/node] {$\l_jon_tikz_diagram_east$} (#1se); \draw[square/south] (\l_jon_tikz_glue_target se) to node [square/south/node] {$\l_jon_tikz_diagram_south$} (#1se); } { \node (#1nw) [square/nw] {$\l_jon_tikz_diagram_nw$}; \node (#1sw) [below = \l_jon_tikz_diagram_height~of~#1nw,square/sw] {$\l_jon_tikz_diagram_sw$}; \draw[square/west] (#1nw) to node [square/west/node] {$\l_jon_tikz_diagram_west$} (#1sw); \node (#1ne) [right = \l_jon_tikz_diagram_width~of~#1nw,square/ne] {$\l_jon_tikz_diagram_ne$}; \node (#1se) [below = \l_jon_tikz_diagram_height~of~#1ne,square/se] {$\l_jon_tikz_diagram_se$}; \draw[square/north] (#1nw) to node [square/north/node] {$\l_jon_tikz_diagram_north$} (#1ne); \draw[square/east] (#1ne) to node [square/east/node] {$\l_jon_tikz_diagram_east$} (#1se); \draw[square/south] (#1sw) to node [square/south/node] {$\l_jon_tikz_diagram_south$} (#1se); } \group_end: } \NewDocumentCommand\SpliceDiagramSquare{D<>{}m}{ \__jon_tikz_render_square:nn {#1} {#2} } \NewDocumentCommand\DiagramSquare{D<>{}O{}m}{ \begin{tikzpicture}[diagram,#2,baseline=(#1sw.base)] \__jon_tikz_render_square:nn {#1} {#3} \end{tikzpicture} } \ExplSyntaxOff ]]> 250ocs-0003ocs-0003.xmlArena AllocatorNote2024529251ocs-0004ocs-0004.xmlLogic behind the allocatorOnly requires an offset or pointer to state the end of the last allocation. To allocate some memory from the arena it is as simple as moving the offset (or pointer) forward. The allocation has the complexity of . Due to being the simplest allocator possible, the arena allocator does nto allow the user to free certain blocks of memory. The memory is usually freed all at once.252ocs-0005ocs-0005.xmlBasic arena interfaceAn arena is like a stack with extensions, e.g. it can be named.the simplest arena allocator will look something likeWhile this is as simple as it gets, there are two issues with the basic approach * You cannot reuse this procedure for different arenas. * The pointer returned may not be aligned correctly for the data you need. The first issue can be solved by coupling the data into a structure and passing that to the procedure =arena_alloc=.253ocs-0008ocs-0008.xmlBash color codesSnippet254ocs-0009ocs-0009.xmlSingle Instruction Multiple Vector (SIMD)Note2025320Single vector instruction sets are extensions to the original architecture instruction sets, and thus you have to invest extra effort to use and support them. With compiled code, you need to write inline assembly, or use vector intrinsics.255ocs-000Jocs-000J.xmlVector intrinsicsIntrinsics appear like regular libary functions. You include the relevant header, and then you can use it just like any other lib. E.g. assuming a visual c++ compiler, if you wanted to add four float numbers to another four numbers, you would include the xmmintrin.h header which contains the following declaration for the _mm_add_ps intrinsic:However unlike lib functions, intrinsics are implemented directly in compilers. The example SSE intrinsic typically compiles to a single instruction, x86 and amd64 instructions. For the time it takes CPU to call a library function, it might have completed dozen of these functions.For all x86 the current best practice is to use <immintrin.h> which loads in the the correct compatible instruction set. __MMX__ -- X86 MMX :: mmintrin.h __SSE__ -- X86 SSE :: xmmintrin.h __SSE2__ -- X86 SSE2 :: emmintrin.h __VEC__ -- altivec functions :: altivec.h __ARM_NEON__ -- ARM Neon functions :: arm_neon.h Operation Altivec Neon MMX/SSE/SSE2 loading vec_ld vld1q_f32 _mm_set_epi16 vector vec_splat vld1q_s16 _mm_set1_epi16 vec_splat_s16 vsetq_lane_f32 _mm_set1_pi16 vec_splat_s32 vld1_u8 _mm_set_pi16 vec_splat_s8 vdupq_lane_s16 _mm_load_ps vec_splat_u16 vdupq_n_s16 _mm_set1_ps vec_splat_u32 vmovq_n_f32 _mm_loadh_pi vec_splat_u8 vset_lane_u8 _mm_loadl_pi storing vec_st vst1_u8 vector vst1q_s16 _mm_store_ps vst1q_f32 vst1_s16 add vec_madd vaddq_s16 _mm_add_epi16 vec_mladd vaddq_f32 _mm_add_pi16 vec_adds vmlaq_n_f32 _mm_add_ps subtract vec_sub vsubq_s16 multiply vec_madd vmulq_n_s16 _mm_mullo_epi16 vec_mladd vmulq_s16 _mm_mullo_pi16 vmulq_f32 _mm_mul_ps vmlaq_n_f32 arithmetic vec_sra vshrq_n_s16 _mm_srai_epi16 shift vec_srl _mm_srai_pi16 vec_sr byte vec_perm vtbl1_u8 _mm_shuffle_pi16 permutation vec_sel vtbx1_u8 _mm_shuffle_ps vec_mergeh vget_high_s16 vec_mergel vget_low_s16 vdupq_lane_s16 vdupq_n_s16 vmovq_n_f32 vbsl_u8 type vec_cts vmovl_u8 _mm_packs_pu16 conversion vec_unpackh vreinterpretq_s16_u16 vec_unpackl vcvtq_u32_f32 vec_cts vqmovn_s32 _mm_cvtps_pi16 vec_ctu vqmovun_s16 _mm_packus_epi16 vqmovn_u16 vcvtq_f32_s32 vmovl_s16 vmovq_n_f32 vector vec_pack vcombine_u16 combination vec_packsu vcombine_u8 vcombine_s16 maximum _mm_max_ps minimum _mm_min_ps vector _mm_andnot_ps logic _mm_and_ps _mm_or_ps rounding vec_trunc misc _mm_empty Links Utilizing the other 80% of your system's performance: Starting with Vectorization Improving perf with simd intrinsics in three use cases Basics of SIMD programming SIMD Keyword OpenMP, R, Parallelism SIMD a practical guide Organizing SIMD code - stackoverflow SSE SSE2 and SSE3 for GNU C++ [closed] - stackoverflow SIMD, memory locality, vectorization, and branch point prediction Code in ARM assembly: Rounding and arithmetic (scalar) Comparing SIMD on x86-64 and arm64256ocs-000Bocs-000B.xmlMakefilesNote2024913A well written makefile describes all the files and settings used to compile a project and link it with the appropriate librariesManaging a build with a makefile is less error-prone and far simpler after a _one-time setup cost_. A makefile with a proper dependency graph will only rebuild a target when one or more of the components it depends on has changed. This allows seperating the components of a project whcih can be built independently.257ocs-000Docs-000D.xmlMakefile syntaxIt is common practice to copy and modify old makefules rather than generating new ones from scratch.258ocs-000Eocs-000E.xmlMakefile macrosSubsitutions defined toward top of the file, e.g. (CFLAGS = -g -Wall), and are similar to #define in C . It can be referenced later with $(CFLAGS).Example macros: - OBJECTS = $(SOURCES:.c=o) - Defines the OBJECTS macro to be the same as the SOURCES macro except that every instance of .c is replaced with .o. - $@: - built-in, name of the current target - $^: - built-in, current targets list of dependencies259ocs-000Focs-000F.xmlTargetsWritten in the following formwhere the target name is the name of the file that will be produced when this target is built. The first target listed in a make file is the default target, meaning it is invoked by make with no args.260ocs-000Cocs-000C.xmlPhony targetsThe clean target in the example does not fit the pattern which is previously described of targets. It does not create a file named clean, rather it is a shortcut for running a command whcih cclears out the projects build files. These commands are listed as dependencies of .PHONY which allows Make to run the target without any dependency checks.linkscs107 makefile guide Makefile basics - gist261go-00rsgo-00rs.xmlGolangLanguage262go-00rvgo-00rv.xmlInitialize moduleWithin a new directory, initialize a module withThis will create a new file `go.mod`263go-00rxgo-00rx.xmlTypes Zero: Predeclared Default value assigned to declared but unassigned variables Literals: Predeclared Explicitly specified values Integer: Literals Base 10 by default Floating-point: Literals Uses decimal point for fractions Rune: Literals Single character representation String: Literals Two creation methods Booleans: Predeclared Binary true/false values byte: Integer Alias for uint8 int: Integer Signed integer sized to architecture's word size uint: Integer Unsigned integer sized to architecture's word size rune: Integer Alias for int32 uintptr: Integer Integer type for storing pointer values String: Predeclared Immutable sequence of bytes, zero value is empty string 264go-00rygo-00ry.xmlType conversionGo does not support automatic type conversion. All variable types need to be converted to interact.265go-00rzgo-00rz.xmlQuotesDifferent qoutes are used for different contexts.The double qoute " will be used to create string literals, while the backtick is used to create raw string literals. The single qoute ' is used to create runes, a single unicode point. E.g. r := '學'.266go-00s0go-00s0.xmlSlicesSlices will have a zero value of nil and is only comprable with nil and ==. Modifying shared slices will affect all references. Length can differ from capacity267go-00s3go-00s3.xmlCreation268go-00s4go-00s4.xmlModification269go-00s5go-00s5.xmlSlicing270go-00s6go-00s6.xmlCopying271go-00s7go-00s7.xmlArray Conversion272go-00s9go-00s9.xmlWhen to Use What1. `var` declaration (nil slice): When size unknown, no initial data 2. Slice literal: When starting values are known 3. `make`: - With length: For buffers or exact size known - Zero length + capacity: For growing slices273go-00sago-00sa.xmlMemory Management- Capacity doubles when &lt; 256 - Growth slows to ~25/for larger slices - Use full slice expression `s[low:high:max]` to prevent capacity issues - Be careful with shared memory when slicing274go-00sbgo-00sb.xmlStandard Library- `slices.Equal(a, b)`: Compare if length and elements match - `slices.EqualFunc(a, b, fn)`: Custom comparison function275go-00scgo-00sc.xmlMapsMaps are declared as `map[keyType]valueType`. A `nil` map (e.g., `var m map[string]int`) cannot be written to. Use `make` or a map literal for writable maps.276go-00sdgo-00sd.xmlStructsStructs are user-defined types with fields. Define them with `type` and access fields using dot notation.Anonymous structs are inline struct definitions:277go-00sego-00se.xmlPointersUse `&` to get a pointer and `*` to dereference. `nil` pointers cannot be dereferenced.278go-00sfgo-00sf.xmlShadowingInner-scope variables can shadow outer-scope ones: 5 { x := 5 fmt.Println(x) // 5 } fmt.Println(x) // 10]]>279go-00sggo-00sg.xmlControl Flow280go-00shgo-00sh.xmlIfGo's `if` statements do not require parentheses. You can declare variables scoped to the condition: 5 { fmt.Println("Big:", n) } else { fmt.Println("Small:", n) }]]>281go-00sigo-00si.xmlForLoops in go support complete (C-style), condition only, for-range styles.If you don't need the key/index in, the underscore _ can be used, telling go to ignore the value.If you just need the key/index, you can leave off the second variable:282go-00sjgo-00sj.xmlSwitch283go-00skgo-00sk.xmlFunctions284go-00slgo-00sl.xmlVariadic ParametersVariadic functions accept a variable number of arguments as a slice:285go-00smgo-00sm.xmlMultiple Return ValuesFunctions can return multiple values, often used with errors:286go-00sngo-00sn.xmlNamed return valuesFunctions can have names specified for the return values, which predeclares variables that are used within the function to hold the return values. These values are initialized to their zero values allowing you to return them before any explicit use or assignment.287go-00spgo-00sp.xmlClosuresThese are functions defined _within_ a function, and are able to access and modify variables declared in the outer function. Closures allow you to pass fome function state to another function. These can also be returned from a function.Anonymous function `f` can read and write `a` even though `a` is not passed in to the function. Using `:=` instead of `=` inside the closure creates a new `a` that ceases to exist when the closure exits.288go-00sqgo-00sq.xmlWhy use closures?Limit function scope If a function is going to be called from only one other function, but it's called multiple times, you can use an inner function to "hide" the called function. This reduces the number of declarations at a package level, making it easier to find an unused name. Removing logic repetetion Given a piece of logic that is repeated multiple times within a function, a closure can be used to remove that repetition. Passing to funcs/returning from funcs These become really interesting, allowing you to take variables within your function and use those variables outside of the function289go-00svgo-00sv.xmlPointersStandard address (`&`) and indirection/dereferencing (`*`) operators. Pointer tricks such as _pointer arithmetic_ that you can do in C are not allowed in go.Before dereferencing a pointer, you must make sure it is non-nil, otherwise the program will panic if you attempt to dereference a `nil` pointer:The pointer type can be based on any type, and the built in function `new` creates a pointer variable which returns a pointer to a zero-value instance of the type.However, the `new` function is rarely used.For structs use `&` before a struct literal to create a pointer instance. When you need a pointer to a primitive type, declare a variable and then point to it.290go-00swgo-00sw.xmlPointers of constants / literalsConstant literals cannot use `&` because they don't have a memory address, e.g.There are two ways around the problem. The first is to introduce a variable to hold the constant. The second is to write a generic helper function that takes a parameter of any type and returns a pointer to that type:which allows one to write the previous code as**NOTE**: The only time you should use pointer parameters to modify a variable is when the function expects an interface, e.g. JSON.291go-00sxgo-00sx.xmlDifference between maps and slicesWithin the go runtime, a map is implemented as a pointer to a struct, so passing a map to a function means that you are copying a pointer. Thus changes made to a map within the functions are reflected in the original.**NOTE**: maps for input parameters or return values should be carefully considered. On an API design level, they are a bad choice because they say nothing about the values contained within. In general one should prefer a struct for these cases.A slice is more complicated. Any modification to a slices contents within a function is reflected in the original, but using append to change the length of the array is not, even if the slice has a capacity greater than its length. This is due to slice being implemented a struct with three fields:int for length int for capcity a pointer to a block of memory292ocs-000Nocs-000N.xmlEnums in GoNote202632Go does not have enums like other languages e.g. with an `enum` keyword, but it's fairly straight forward to implement and extend the same functionality.The following defines the type that will enumerate our variables, and then we construct the enumeration as constants.That we can create a new type to alias each of these constants, instead of just doing something like `OPS int = iota`, makes it so that we can actually reliably use these enumerated values in a type safe way.This way we can define methods that only operate on `Environment` types, instead of just `int` types. E.g. the following methods take a `Environment` and return a corresponding endpoint/url.Since the underlying type of the enums values are just `int`s, we can also use them just as we would `int`s. SITS { return fmt.Sprintf("Unkown(%d)", e) } return names[e] }]]>