Insyra

https://github.com/hazelnutparadise/insyra
Admin
Insyra is a next-generation data analysis library for Golang, offering dynamic and versatile tools...
Tokens:1,229,130
Snippets:7,626
Trust Score:7
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
================
LIBRARY RULES
================
- Pay attention to insyra syntax and be sure to provide the correct answer.
- Always use syntactic sugar(isr package) unless in performance-critical scenarios.

================
CODE SNIPPETS
================
### Install Insyra with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/README.md

Installs the main Insyra package. Use this to get started with the core library.

```bash
go get github.com/HazelnutParadise/insyra
```

--------------------------------

### Install accel with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/accel.md

Installs the accel package from the root module. Part of allpkgs, so the standard install includes it.

```bash
go get github.com/HazelnutParadise/insyra/accel
```

--------------------------------

### Install quant package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Use this command to install the quant package from the GitHub repository.

```bash
go get github.com/HazelnutParadise/insyra/quant
```

--------------------------------

### Install lp package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/lp.md

Use this command to install the lp package from the GitHub repository.

```bash
go get github.com/HazelnutParadise/insyra/lp
```

--------------------------------

### Install parallel package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/parallel.md

Install the parallel package using the go get command.

```bash
go get github.com/HazelnutParadise/insyra/parallel
```

--------------------------------

### Start REPL

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Launch the interactive REPL. Empty lines and lines starting with # are ignored.

```bash
insyra
```

--------------------------------

### Example usage of ToneCounts and DailyTone

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Shows how to call ToneCounts with a negation window and DailyTone with close time, location, and rolling windows. The example uses a New York location and a 5-day window for NetTone and 60-day window for Z-score.

```go
counts, err := quant.ToneCounts(headlines, lex, quant.ToneOptions{NegationWindow: 3})
daily, err := quant.DailyTone(publishedAt, counts, tradingDays,
    quant.DailyToneOptions{CloseHour: 16, Location: newYork, Window: 5, ZWindow: 60})
```

--------------------------------

### Install datafetch package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/datafetch.md

Install the datafetch package using the go get command. Requires Go and network access.

```bash
go get github.com/HazelnutParadise/insyra/datafetch
```

--------------------------------

### Install mkt package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/mkt.md

Use this command to install the mkt package from the GitHub repository.

```bash
go get github.com/HazelnutParadise/insyra/mkt
```

--------------------------------

### Install Insyra and parquet packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/parquet-inspection-streaming-and-filter.md

Install the required Go packages before starting the tutorial.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/parquet
```

--------------------------------

### Install all Insyra packages at once

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/README.md

Installs every package including accel, stats, plot, and others. The accel package is included, so GPU acceleration is available after this install.

```bash
go get github.com/HazelnutParadise/insyra/allpkgs
```

--------------------------------

### Go DSL session example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Create a DSL session and execute commands. Uses dsl.NewSession with dsl.DefaultManager(). Execute accepts the same syntax as REPL and .isr.

```go
package main

import (
    "fmt"

    "github.com/HazelnutParadise/insyra/engine/dsl"
)

func main() {
    session, err := dsl.NewSession(dsl.DefaultManager(), "default", nil)
    if err != nil {
        panic(err)
    }

    if err := session.Execute("newdl 1 2 3 as x"); err != nil {
        panic(err)
    }
    if err := session.Execute("mean x"); err != nil {
        panic(err)
    }

    fmt.Println("vars:", len(session.Context().Vars))
}
```

--------------------------------

### Install finance package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/finance.md

Install the finance package using the go get command. The package depends on github.com/TimLai666/go-decimal, which is added automatically by go mod tidy.

```bash
go get github.com/HazelnutParadise/insyra/finance
```

--------------------------------

### Install Insyra and optimization packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/capacity-planning-with-lp-and-lpgen.md

Install the required Go packages for the tutorial: insyra, lp, and lpgen.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/lp
go get github.com/HazelnutParadise/insyra/lpgen
```

--------------------------------

### FamaMacBeth usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Runs Fama-MacBeth regression with Standardize option and prints coefficients and t-values. The result includes Names, Coefs, and TValues per characteristic.

```go
res, err := quant.FamaMacBeth(panel, "date", "ret_next", []string{"momentum", "size", "bias"},
    quant.FamaMacBethOptions{Standardize: true})
for i, name := range res.Names {
    fmt.Printf("%s: %.4f (t = %.2f)\n", name, res.Coefs[i], res.TValues[i])
}
```

--------------------------------

### Go dsl.NewSession and Execute example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Creates a DSL session with `dsl.NewSession(dsl.DefaultManager(), "demo", &out)` and executes four commands: load, filter, summary, and save. The session writes output to a bytes.Buffer, which is printed after execution. Requires importing `github.com/HazelnutParadise/insyra/engine/dsl`.

```go
package main

import (
    "bytes"
    "fmt"

    "github.com/HazelnutParadise/insyra/engine/dsl"
)

func main() {
    var out bytes.Buffer

    session, err := dsl.NewSession(dsl.DefaultManager(), "demo", &out)
    if err != nil {
        panic(err)
    }

    _ = session.Execute("load sales.csv as t")
    _ = session.Execute("filter t \"['amount'] > 1000\" as t_high")
    _ = session.Execute("summary t_high")
    _ = session.Execute("save t_high high_sales.csv")

    fmt.Println(out.String())
}
```

--------------------------------

### Install nn package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/nn.md

Install the nn package using the go get command. Requires Go and network access to fetch the module.

```bash
go get github.com/HazelnutParadise/insyra/nn
```

--------------------------------

### Install insyra/ml package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/ml.md

Use this command to install the ml package from the GitHub repository.

```bash
go get github.com/HazelnutParadise/insyra/ml
```

--------------------------------

### Install Insyra and mkt packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/customer-segmentation-rfm-and-cai.md

Install the required Go packages for the tutorial.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/mkt
```

--------------------------------

### Install Insyra and stats packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/ab-test-decision-with-statistics.md

Install the required Go packages for the tutorial.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/stats
```

--------------------------------

### Using VolatilityThresholds and ZigZagAdaptive with SegmentStarts

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant-ta.md

Example usage: compute volatility thresholds and then adaptive zigzag with the same segment starts. The results were validated against an independent implementation on five seeded synthetic series.

```go
th, _ := ta.VolatilityThresholds(close, 3, ta.VolatilityThresholdOptions{SegmentStarts: breaks})
swings, _ := ta.ZigZagAdaptive(close, th, ta.ZigZagOptions{SegmentStarts: breaks})
```

--------------------------------

### regression command examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Shows usage of `regression logistic` and `regression poisson` with the `as` clause for storing the fit.

```bash
insyra regression logistic y x1 x2 as fit
```

```bash
insyra regression poisson y x1 x2
```

--------------------------------

### Install Insyra CLI with go install

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Installs the Insyra CLI binary from the latest version. The executable is placed in $GOBIN (or $GOPATH/bin if $GOBIN is unset). On Windows, add the bin directory to PATH and restart the terminal if the command is not found.

```bash
go install github.com/HazelnutParadise/insyra/cmd/insyra@latest
```

--------------------------------

### describe command examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Creates DataTable summaries. Without `as`, the result is stored in `$result`. `all true` includes non-numeric and mixed columns. `by` is available for DataTable variables only. `percentiles` must be fractions between 0 and 1; values outside that range are refused.

```bash
describe sales as summary
describe sales all true as summary_all
describe sales percentiles 0.1,0.5,0.9 as summary_p
describe sales by region all true as region_summary
save region_summary region_summary.csv
```

--------------------------------

### Install Insyra packages with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/market-trend-forecasting-with-yfinance.md

Run these commands to install the required Insyra packages for the tutorial. Requires Go 1.26+.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/datafetch
go get github.com/HazelnutParadise/insyra/stats
go get github.com/HazelnutParadise/insyra/plot
```

--------------------------------

### Advanced RFM Configuration in Go

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/mkt.md

Shows alternative RFMConfig setups: using column names instead of indices, changing date format, and mixed usage where index takes precedence over name when both are provided. Includes a 3-point scale example and ISO date format.

```go
// Using column names instead of indices
config := mkt.RFMConfig{
    CustomerIDColName:  "CustomerID",
    TradingDayColName:  "PurchaseDate",
    AmountColName:      "TotalAmount",
    NumGroups:          3,  // 3-point scale (Low/Medium/High)
    DateFormat:         "02/01/2006",  // DD/MM/YYYY format
}

// For European date format
config.DateFormat = "2006-01-02"  // ISO format

// Mixed usage (index takes precedence if both are provided)
config := mkt.RFMConfig{
    CustomerIDColIndex: "A",           // This will be used
    CustomerIDColName:  "CustomerID",  // Ignored
    TradingDayColIndex: "B",
    AmountColIndex:     "C",
    NumGroups:          5,
    DateFormat:         "2006-01-02",
}

```

--------------------------------

### Example: Using PipFreeze to get pip freeze output

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Calls py.PipFreeze() and prints each line. Handles errors by printing a failure message.

```go
lines, err := py.PipFreeze()
if err != nil {
    fmt.Println("Failed to run pip freeze:", err)
} else {
    for _, l := range lines {
        fmt.Println(l)
    }
}
```

--------------------------------

### Install insyra quant/ta package

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant-ta.md

Install the Go package for technical analysis tools. Use this command to add the library to your project.

```bash
go get github.com/HazelnutParadise/insyra/quant/ta
```

--------------------------------

### Install individual Insyra sub-packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/README.md

Installs specific sub-packages individually. The comment indicates that more packages can be added in the same manner.

```bash
go get github.com/HazelnutParadise/insyra/accel
go get github.com/HazelnutParadise/insyra/stats
go get github.com/HazelnutParadise/insyra/plot
# ... and so on
```

--------------------------------

### insyra.Return example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Example of using insyra.Return to return a dictionary with a message and value to Go.

```python
insyra.Return({
 "message": "Hello from Python",
 "value": 123,
})
```

--------------------------------

### Get method example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataList.md

Example usage of Get with negative indexing: Get(0) returns the first element, Get(-1) the last, and Get(-2) the second-to-last.

```go
dl := insyra.NewDataList(10, 20, 30, 40, 50)
fmt.Println(dl.Get(0))  // 10 (first element)
fmt.Println(dl.Get(-1)) // 50 (last element)
fmt.Println(dl.Get(-2)) // 40 (second to last)
```

--------------------------------

### DSL variable alias examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Shows how `as <var>` assigns a result to a named variable; when omitted, the result defaults to `$result`. Lines starting with `#` are comments.

```text
newdl 1 2 3 as x
newdl 4 5 6
# second command writes to $result
```

--------------------------------

### Initialize Go module

Source: https://github.com/hazelnutparadise/insyra/blob/main/README.md

Run this command to create a new Go module for your project. Replace 'your_project_name' with your actual module name.

```sh
go mod init your_project_name
```

--------------------------------

### Install gplot with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/gplot.md

Install the gplot package using the go get command.

```bash
go get github.com/HazelnutParadise/insyra/gplot
```

--------------------------------

### Install plot package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/plot.md

Install the plot package using the go get command.

```bash
go get github.com/HazelnutParadise/insyra/plot
```

--------------------------------

### Example usage of MACD, KD, and Bollinger

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant-ta.md

Shows how to call the MACD, KD, and Bollinger functions with typical parameters (12, 26, 9 for MACD; 9 for KD; 20, 2 for Bollinger). Errors are ignored with blank identifier.

```go
macd, _ := ta.MACD(close, 12, 26, 9)
kd, _ := ta.KD(high, low, close, 9)
bands, _ := ta.Bollinger(close, 20, 2)
```

--------------------------------

### PipInstallContext

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Installs a Python dependency with context-aware cancellation. Accepts a context.Context to control the installation.

```APIDOC
## PipInstallContext

### Description
Installs a Python dependency with context-aware cancellation. Accepts a context.Context to control the installation.

### Function Signature
```go
func PipInstallContext(ctx context.Context, dep string) error
```

### Parameters
- `ctx` (context.Context) - Required - The context used to control cancellation and deadlines for the installation.
- `dep` (string) - Required - The name of the dependency to install.

### Returns
- `error`: Non-nil if installation failed; if canceled via the provided `ctx`, returns `ctx.Err()`.
```

--------------------------------

### BacktestSignal usage with ZigZag and options

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Example of calling BacktestSignal with a ZigZag signal and specifying buy and sell costs. The signal is generated from the close prices, and the backtest uses the given returns and cost options.

```go
swings, err := ta.ZigZag(close, 0.10)
res, err := quant.BacktestSignal(signal, returns, quant.BacktestOptions{BuyCost: 0.0015, SellCost: 0.0045})
```

--------------------------------

### Complete example: Search stores and fetch reviews with GoogleMapsStores

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/datafetch.md

Initializes the Google Maps crawler, searches for stores, fetches reviews for the first store with custom options, converts to a DataTable, displays the first 5 reviews, and exports to CSV. Requires a stable internet connection; every request times out after 30 seconds and progress is logged at debug level. Store IDs are in the format 0x...:0x... and nil returns should be handled.

```go
package main

import (
    "fmt"
    "log"
    "time"

    "github.com/HazelnutParadise/insyra/datafetch"
)

func main() {
    // Initialize crawler
    crawler := datafetch.GoogleMapsStores()

    // Search for stores
    stores := crawler.Search("Apple Store Taipei")
    if len(stores) == 0 {
        log.Fatal("No stores found")
    }

    fmt.Printf("Found %d stores\n", len(stores))
    for i, store := range stores {
        fmt.Printf("  %d. %s\n", i+1, store.Name)
    }

    // Fetch reviews for the first store with custom options
    options := datafetch.GoogleMapsStoreReviewsFetchingOptions{
        SortBy:             datafetch.GoogleMapsStoreReviewSortByNewest,
        MaxWaitingInterval: 2 * time.Second,
    }

    reviews := crawler.GetReviews(stores[0].ID, 2, options)
    if reviews == nil {
        log.Fatal("Failed to fetch reviews")
    }

    // Convert to DataTable
    dt := reviews.ToDataTable()
    rows, _ := dt.Size()
    fmt.Printf("\nFetched %d reviews\n", rows)

    // Display first 5 reviews
    dt.ShowRange(5)

    // Export to CSV
    dt.ToCSV("apple_store_reviews.csv", false, true, false)
    fmt.Println("\nReviews exported to apple_store_reviews.csv")
}

```

--------------------------------

### CSV configuration examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/isr.md

Shows how to configure CSV input/output options for file and string sources, and use them to create DataTables.

```go
// CSV from file
csvFromFile := isr.CSV{
    FilePath: "data.csv",
    InputOpts: isr.CSV_inOpts{
        FirstCol2RowNames: true,
        FirstRow2ColNames: true,
        Encoding:          "big5", // Specify file encoding
    },
    OutputOpts: isr.CSV_outOpts{
        RowNames2FirstCol: true,
        ColNames2FirstRow: true,
    },
}

// CSV from string
csvFromString := isr.CSV{
    String: "name,age,city\nJohn,30,NYC\nJane,25,LA",
    InputOpts: isr.CSV_inOpts{
        FirstCol2RowNames: false,
        FirstRow2ColNames: true,
    },
}

// Use in DataTable creation
dataTable1 := isr.DT.From(csvFromFile)
dataTable2 := isr.DT.From(csvFromString)
```

--------------------------------

### GetColNameByIndex usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example that gets the name of column A and prints it.

```go
columnName := dt.GetColNameByIndex("A")
fmt.Printf("Name of column A: %s\n", columnName)
```

--------------------------------

### Run Go project

Source: https://github.com/hazelnutparadise/insyra/blob/main/README.md

Executes the main.go file in your project.

```sh
go run main.go
```

--------------------------------

### ta.TDSequential

Source: https://github.com/hazelnutparadise/insyra/blob/main/openspec/specs/ta-price-structure/spec.md

Counts TD Sequential setups (1-9) and countdowns (to 13) based on close prices. A buy setup occurs when closes are below the close four rows earlier; a sell setup when above. Countdowns start after a completed setup and count rows closing at or beyond the close two rows earlier. A new setup starts after a countdown reaches 13, and the countdown is cancelled if the opposite setup completes.

```APIDOC
## ta.TDSequential

### Description
Counts TD Sequential setups (1-9) and countdowns (to 13) based on close prices. A buy setup occurs when closes are below the close four rows earlier; a sell setup when above. Countdowns start after a completed setup and count rows closing at or beyond the close two rows earlier. A new setup starts after a countdown reaches 13, and the countdown is cancelled if the opposite setup completes.

### Method
Function call

### Endpoint
`ta.TDSequential`

### Parameters
- **close** (series) - Required - Close prices.

### Response
Returns setup and countdown counts for each row.

### Notes
This implementation differs from DeMark's original rule set: it compares the close with the close two rows earlier in the countdown (DeMark uses low/high), and a setup that goes past 9 restarts from 1. It does not claim to match the original.

### Example
For nine consecutive closes below the close four rows earlier, the buy setup reads 1 to 9 and the buy countdown starts on the next row. For ten such rows, the tenth row's buy setup reads 1.
```

--------------------------------

### PipInstall

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Installs a Python dependency using uv pip. Returns an error if installation fails.

```APIDOC
## PipInstall

### Description
Installs a Python dependency using uv pip. Returns an error if installation fails.

### Function Signature
```go
func PipInstall(dep string) error
```

### Parameters
- `dep` (string) - Required - The name of the dependency to install.

### Returns
- `error`: Non-nil if installation failed; nil otherwise.
```

--------------------------------

### GetColNameByNumber usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example that gets the name of the first column and prints it.

```go
columnName := dt.GetColNameByNumber(0)
fmt.Printf("Name of the first column: %s\n", columnName)
```

--------------------------------

### Example: Reinstalling Python environment

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Calls py.ReinstallPyEnv() and prints success or failure messages. Includes necessary imports and main function.

```go
package main

import (
 "fmt"
 "github.com/HazelnutParadise/insyra/py"
)

func main() {
 err := py.ReinstallPyEnv()
 if err != nil {
     fmt.Println("Failed to reinstall Python environment:", err)
 } else {
     fmt.Println("Python environment reinstalled successfully!")
 }
}
```

--------------------------------

### JSON configuration examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/isr.md

Shows how to load JSON from a file or byte data and use it to create DataTables.

```go
// Load from JSON file
jsonFromFile := isr.JSON{
    FilePath: "data.json",
}

// Load from JSON byte data
jsonData := []byte(`[{"name":"John","age":30},{"name":"Jane","age":25}]`)
jsonFromBytes := isr.JSON{
    Bytes: jsonData,
}

// Use in DataTable creation
dataTable1 := isr.DT.From(jsonFromFile)
dataTable2 := isr.DT.From(jsonFromBytes)
```

--------------------------------

### Percentile usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataList.md

Example of calling Percentile to get the 75th percentile.

```go
dl := insyra.NewDataList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
p75 := dl.Percentile(75) // 75th percentile
```

--------------------------------

### SliceRows usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example calls to SliceRows: firstTen gets rows 0-9, fromRow5 gets rows 5 to the end. After the calls, check dt.Err() to see if a bound was outside the table.

```go
firstTen := dt.SliceRows(0, 10)
fromRow5 := dt.SliceRows(5, dt.NumRows())
if err := dt.Err(); err != nil {
    // a bound was outside the table
}
```

--------------------------------

### Example usage of DetectPatterns with PatternOptions

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant-ta.md

Shows how to call DetectPatterns with PatternOptions and iterate over the returned patterns. The example checks for an ascending triangle pattern with a breakout and comments on trading at the breakout row.

```go
patterns, _ := ta.DetectPatterns(close, swings, ta.PatternOptions{SegmentStarts: breaks})
for _, p := range patterns {
    if p.Kind == ta.PatternAscendingTriangle && p.BreakoutAt >= 0 {
        // p.Direction is where it went; trade on p.BreakoutAt, not p.Start
    }
}
```

--------------------------------

### IsTheSameAs example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example showing that a table and its Clone() are always the same, even after setting row names.

```go
dt := insyra.NewDataTable(insyra.NewDataList(1, 2).SetName("x"))
dt.SetRowNames([]string{"r1", "r2"})
dt.IsTheSameAs(dt.Clone()) // true
```

--------------------------------

### GetColIndexByName usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example that gets the column index for a named column and prints it.

```go
index := dt.GetColIndexByName("column_name")
fmt.Printf("Column index: %s\n", index)
```

--------------------------------

### Len method example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataList.md

Example usage of Len to get the element count of a DataList.

```go
dl := insyra.NewDataList(1, 2, 3, 4, 5)
fmt.Println(dl.Len()) // 5
```

--------------------------------

### Install Insyra and gplot

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/static-executive-report-with-gplot.md

Install the Insyra and gplot packages using Go modules.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/gplot
```

--------------------------------

### Install isr Package

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/isr.md

Command to install the isr package using go get.

```bash
go get github.com/HazelnutParadise/insyra/isr
```

--------------------------------

### GetColNumberByName usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example that gets the numeric index of a column and prints it or a not-found message.

```go
index := dt.GetColNumberByName("column_name")
if index != -1 {
    fmt.Printf("Column index: %d\n", index)
} else {
    fmt.Println("Column not found")
}
```

--------------------------------

### Example usage of NeweyWestMeanTest

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/stats.md

Example showing how to call NeweyWestMeanTest with stats.AutoLag, handle errors, and print results.

```go
result, err := stats.NeweyWestMeanTest(dailyReturns, stats.AutoLag)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("mean=%.5f, t=%.2f (lag %d)\n", result.Mean, result.Statistic, result.Lag)
```

--------------------------------

### Complete runnable Go program for sales analysis

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/sales-analysis-end-to-end.md

Full program that writes a sample CSV, reads it with insyra.ReadCSV_File, adds derived columns using AddColUsingCCL, sorts by NetSales descending, computes metrics, shows the top 5 rows, and exports to CSV. Demonstrates the entire end-to-end workflow.

```go
package main

import (
	"fmt"
	"log"
	"os"

	"github.com/HazelnutParadise/insyra"
)

func main() {
	csv := `OrderID,Region,Product,Quantity,UnitPrice,DiscountRate,Cost
1001,North,Laptop,2,1200,0.05,1800
1002,South,Mouse,10,25,0,140
1003,East,Monitor,3,300,0.10,700
1004,West,Keyboard,5,80,0.05,250
1005,North,Laptop,1,1250,0.08,900
1006,South,Dock,4,150,0.00,420
1007,East,Headset,6,60,0.15,250
1008,West,Monitor,2,320,0.05,480
`
	if err := os.WriteFile("sales.csv", []byte(csv), 0644); err != nil {
		log.Fatal(err)
	}

	dt, err := insyra.ReadCSV_File("sales.csv", false, true)
	if err != nil {
		log.Fatal(err)
	}

	dt.AddColUsingCCL("GrossSales", "['Quantity'] * ['UnitPrice']")
	dt.AddColUsingCCL("NetSales", "['GrossSales'] * (1 - ['DiscountRate'])")
	dt.AddColUsingCCL("Profit", "['NetSales'] - ['Cost']")

	dt.SortBy(insyra.DataTableSortConfig{
		ColumnName: "NetSales",
		Descending: true,
	})

	netSales := dt.GetColByName("NetSales")
	profit := dt.GetColByName("Profit")
	if netSales == nil || profit == nil {
		log.Fatal("required derived columns not found")
	}

	fmt.Printf("Total Net Sales: %.2f\n", netSales.Sum())
	fmt.Printf("Average Order Value: %.2f\n", netSales.Mean())
	fmt.Printf("Total Profit: %.2f\n", profit.Sum())

	dt.ShowRange(5)

	if err := dt.ToCSV("sales_enriched.csv", false, true, false); err != nil {
		log.Fatal(err)
	}
	fmt.Println("Wrote sales_enriched.csv")
}
```

--------------------------------

### Create main.go with basic Insyra import

Source: https://github.com/hazelnutparadise/insyra/blob/main/README.md

A minimal Go program that imports Insyra. This is the starting point for your project.

```go
package main

import (
    "fmt"
    "github.com/HazelnutParadise/insyra"
)

func main() {
    // Your code here
}
```

--------------------------------

### Quick Start: Create and Append to DataList

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/isr.md

Shows the basic usage of the isr package: create a DataList with values 1-4, append 5, and display it. Requires importing the isr package.

```go
import "github.com/HazelnutParadise/insyra/isr"

dl := isr.DL.Of(1, 2, 3, 4).Append(5)
dl.Show()
```

--------------------------------

### Install go-decimal with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/Decimal.md

Install the decimal library used across Insyra for exact arithmetic.

```bash
go get github.com/TimLai666/go-decimal
```

--------------------------------

### Show example usage

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataList.md

Creates a DataList and calls Show to display elements with color coding based on data types.

```go
dl := insyra.NewDataList(1, "hello", 3.14, true)
dl.Show()
// Displays elements with color coding based on data types
```

--------------------------------

### GetColIndexByNumber usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example that gets the column index for the first column and the last column using a negative index.

```go
index := dt.GetColIndexByNumber(0)
fmt.Printf("Column index: %s\n", index)

// Get last column index
lastIndex := dt.GetColIndexByNumber(-1)
fmt.Printf("Last column index: %s\n", lastIndex)
```

--------------------------------

### Quick Start: Create DataList and DataTable

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/README.md

Shows basic usage of Insyra: creating a DataList with numbers, computing the mean, and creating a DataTable with named columns. The DataTable is displayed with Show().

```go
import "github.com/HazelnutParadise/insyra"

// Create a DataList (similar to a column or array)
dl := insyra.NewDataList(1, 2, 3, 4, 5)
fmt.Println(dl.Mean())  // Output: 3

// Create a DataTable (similar to a spreadsheet)
dt := insyra.NewDataTable(
    insyra.NewDataList("Alice", "Bob", "Charlie").SetName("Name"),
    insyra.NewDataList(25, 30, 35).SetName("Age"),
)
dt.Show()
```

--------------------------------

### Count usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Gets the row count and prints it.

```go
count := dt.Count()
fmt.Printf("Table has %d rows\n", count)
```

--------------------------------

### quant portfolio CLI command sequence

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Builds a return table from two TWSE assets and runs `quant portfolio` with maxsharpe and rf 0.0001. Outputs one `<asset>=<weight>` line plus a summary with `return= vol= sharpe= iterations= converged=`. Stores a two-column `Asset, Weight` DataTable under `as w` and a one-row `w_stats` table. A solve hitting the iteration cap reports `converged=false` with best weights, not an error.

```text
fetch tw 2330 adjprices 2026-01-01 2026-08-31 twse as tsmc
fetch tw 2317 adjprices 2026-01-01 2026-08-31 twse as hon_hai
col tsmc AdjClose as tsmc_px
col hon_hai AdjClose as hon_hai_px
pctchange tsmc_px 1 as tsmc_ret
pctchange hon_hai_px 1 as hon_hai_ret
clean tsmc_ret nil
clean hon_hai_ret nil
newdt tsmc_ret hon_hai_ret as rets
setcolnames rets TSMC HonHai
quant portfolio rets maxsharpe rf 0.0001 as w
show w
show w_stats
```

--------------------------------

### Counter usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Gets the value counts map and prints it.

```go
counts := dt.Counter()
fmt.Printf("Value counts: %v\n", counts)
```

--------------------------------

### Advanced Insyra CLI examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/README.md

Shows advanced CLI commands for regression, hypothesis testing, plotting, fetching Yahoo Finance data, partial Parquet loading, and sampling/splitting.

```sh
# Regression
insyra regression linear y x1 x2 as reg

# Hypothesis test
insyra ttest two group_a group_b equal

# Plot
insyra plot line sales save sales.html

# Fetch (Yahoo Finance)
insyra fetch yahoo AAPL quote as q

# Partial Parquet load (selected columns + row groups)
insyra load parquet data.parquet cols id,amount,status rowgroups 0,1 as t

# Reproducible sampling and train/test split
insyra sample t frac 0.1 seed 42 as preview
insyra split t train 0.8 seed 42 as train test
```

--------------------------------

### Install stats package with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/stats.md

Install the stats package using the Go module tool. Run this command in your project directory to add the dependency.

```bash
go get github.com/HazelnutParadise/insyra/stats
```

--------------------------------

### Install Insyra, py, and parallel packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/python-enrichment-and-parallel-batch.md

Run these go get commands to install the required Insyra packages for Python enrichment and parallel processing.

```bash
go get github.com/HazelnutParadise/insyra
go get github.com/HazelnutParadise/insyra/py
go get github.com/HazelnutParadise/insyra/parallel
```

--------------------------------

### Complete runnable Go program

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/tutorials/capacity-planning-with-lp-and-lpgen.md

Full program that defines, solves, and exports the LP capacity plan.

```go
package main

import (
	"log"

	"github.com/HazelnutParadise/insyra"
	"github.com/HazelnutParadise/insyra/lp"
	"github.com/HazelnutParadise/insyra/lpgen"
)

func main() {
	model := lpgen.NewLPModel()
	model.SetObjective("Maximize", "50 x1 + 70 x2")
	model.AddConstraint("2 x1 + 4 x2 <= 240")
	model.AddConstraint("3 x1 + 2 x2 <= 180")
	model.AddBound("0 <= x1 <= 80")
	model.AddBound("0 <= x2 <= 70")
	model.GenerateLPFile("capacity_plan.lp")

	solution, meta := lp.SolveModel(model, 30)
	if solution == nil || meta == nil {
		log.Fatal("solver failed")
	}

	summary := insyra.NewDataTable(
		insyra.NewDataList("Decision", "Description").SetName("Field"),
		insyra.NewDataList("CapacityPlan", "Optimal production under labor/machine constraints").SetName("Value"),
	)

	_ = solution.ToCSV("capacity_solution.csv", false, true, false)
	_ = meta.ToCSV("capacity_meta.csv", false, true, false)
	_ = summary.ToCSV("capacity_summary.csv", false, true, false)
}
```

--------------------------------

### Calling RomanoWolf and iterating over rejected strategies

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Shows how to invoke RomanoWolf with Replications 5000, BlockSize 10, Seed 1, and Alpha 0.1, then print strategies that beat the benchmark with their rejection step and statistic.

```go
res, err := quant.RomanoWolf(perf, quant.RomanoWolfOptions{
    DataSnoopingOptions: quant.DataSnoopingOptions{Replications: 5000, BlockSize: 10, Seed: 1},
    Alpha:               0.1,
})
if err != nil { /* ... */ }
for k, step := range res.RejectedAt {
    if step > 0 {
        fmt.Println(res.Names[k], "beats the benchmark, found at step", step, "statistic", res.Statistics[k])
    }
}
```

--------------------------------

### Install csvxl with go get

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/csvxl.md

Install the csvxl package using the Go module tool. Run this command in your project directory to add the dependency.

```bash
go get github.com/HazelnutParadise/insyra/csvxl
```

--------------------------------

### encode onehot, label, and ordinal examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Three forms produce different results: onehot creates 0/1 columns per category; label writes integer category ids 0..n-1 with sortby deciding which gets 0; ordinal writes 0..n-1 but order list decides positions. ordinal has no unknown new option.

```text
encode sales onehot region,channel dropfirst true as x
encode sales label segment newcol segment_id sortby freq keeporiginal true as labeled
encode survey ordinal satisfaction order low,medium,high unknown error as ranked
```

--------------------------------

### fillna usage examples

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Four example invocations of fillna with different strategies and options: interpolation with extrapolation, forward fill with limit and missing kind, median on specific columns, and backward fill with limit.

```bash
fillna price interpolate extrapolate yes as price_interp
```

```bash
fillna status ffill limit 2 missing nan as status_filled
```

```bash
fillna sales median cols revenue,cost as sales_clean
```

```bash
fillna sales bfill limit 1 as sales_bfill
```

--------------------------------

### Example: Using PipList to list packages

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/py.md

Calls py.PipList() and prints each package as name==version. Handles errors by printing a failure message.

```go
pkgs, err := py.PipList()
if err != nil {
    fmt.Println("Failed to list packages:", err)
} else {
    for name, ver := range pkgs {
        fmt.Printf("%s==%s\n", name, ver)
    }
}
```

--------------------------------

### ScheduleTable usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/finance.md

Creates a schedule table for 12 periods and pretty-prints it to the terminal. Uses finance.Zero for fv and finance.PaymentEnd for timing.

```go
table, _ := finance.ScheduleTable(rate, 12, pv, finance.Zero, finance.PaymentEnd)
table.Show() // pretty-print to terminal
```

--------------------------------

### Beta of a stock against its index with aligned price tables

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/quant.md

Merges asset and index price tables on a Date column using an inner horizontal merge, then computes percentage changes and beta. Uses adjusted prices, not raw closes, to avoid fake losses on ex-dividend days. Prints market beta.

```go
// Each table has a Date column and an adjusted price column. For Taiwan stocks
// that is datafetch's DailyPricesAdjusted "AdjClose"; for Yahoo Finance it is
// "Adj Close". When both tables use the same price column name, the merged table
// keeps the left table's column as "AdjClose" and renames the right one
// "AdjClose_other".
aligned, err := assetPrices.Merge(indexPrices,
    insyra.MergeDirectionHorizontal, insyra.MergeModeInner, "Date")
if err != nil {
    log.Fatal(err)
}

assetReturns := aligned.PctChangeCol("AdjClose", 1).ClearNils()       // asset
marketReturns := aligned.PctChangeCol("AdjClose_other", 1).ClearNils() // index
beta, err := quant.Beta(assetReturns, marketReturns)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("market beta = %.3f\n", beta)
```

--------------------------------

### Method chaining with From, Push, At

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/isr.md

All operations can be chained. This example creates a DataList from 1,2,3, pushes 4,5, and gets the element at index 3, which returns 4.

```go
// All operations can be chained
result := isr.DL.From(1, 2, 3).Push(4, 5).At(3) // Returns 4
```

--------------------------------

### ToSQL usage examples with MySQL and options

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Shows three usage patterns: replacing an existing table, appending with a custom batch size, and a cancelable write with a schema prefix. The first example opens a MySQL connection; the others assume an existing dt and db.

```go
db, _ := gorm.Open(mysql.Open("connection_string"))

// Replace existing table if present.
err := dt.ToSQL(db, "users", ToSQLOptions{IfExists: SQLActionIfTableExistsReplace})
if err != nil {
    log.Fatal(err)
}

// Append into an existing table; missing columns are added once.
err = dt.ToSQL(db, "events", ToSQLOptions{
    IfExists:  SQLActionIfTableExistsAppend,
    BatchSize: 1000,
})

// Cancelable write with a deadline.
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
err = dt.ToSQLContext(ctx, db, "events_archive", ToSQLOptions{
    IfExists: SQLActionIfTableExistsReplace,
    Schema:   "analytics",
})
```

--------------------------------

### Run all tests

Source: https://github.com/hazelnutparadise/insyra/blob/main/AGENTS.md

Runs the entire Go test suite for the project.

```bash
go test ./...
```

--------------------------------

### ColNames - Get column names

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Returns a slice containing all column names in order. The example iterates over the names and prints each column index with its name or '(unnamed)' if empty.

```go
func (dt *DataTable) ColNames() []string
```

```go
names := dt.ColNames()
for i, name := range names {
    if name != "" {
        fmt.Printf("Column %d: %s\n", i, name)
    } else {
        fmt.Printf("Column %d: (unnamed)\n", i)
    }
}
```

--------------------------------

### CreationTime usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Prints the table creation time.

```go
fmt.Println("Created at:", dt.CreationTime())
```

--------------------------------

### ColDataTypes - Get column data types

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Returns each column's DataType in column order, similar to ColNames. The example checks if each column's type is insyra.DataTypeNumber and prints the column name if so.

```go
func (dt *DataTable) ColDataTypes() []DataType
```

```go
names := dt.ColNames()
for i, t := range dt.ColDataTypes() {
    if t == insyra.DataTypeNumber {
        fmt.Println(names[i], "can be analysed")
    }
}
```

--------------------------------

### Negative numbers in one-shot mode

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

`newdl`, `addrow`, and `addcol` disable flag parsing, so negative values need no special handling. Other commands require a bare `--` before values starting with `-`.

```bash
insyra newdl 0.01 -0.004 0.02 as r
```

```bash
insyra set dt 0 A -- -2.5
insyra shift x 1 fill -- -1
```

--------------------------------

### FactorAnalysis usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/stats.md

Configures and runs factor analysis with ML extraction, oblimin rotation, and regression scoring. Prints loadings, communalities, KMO, Bartlett, and scores.

```go
opt := stats.DefaultFactorAnalysisOptions()
opt.Count.Method = stats.FactorCountFixed
opt.Count.FixedK = 3
opt.Extraction = stats.FactorExtractionML
opt.Rotation.Method = stats.FactorRotationOblimin
opt.Scoring = stats.FactorScoreRegression

res, err := stats.FactorAnalysis(dt, opt)
if err != nil {
    log.Fatal(err)
}
res.Show()  // prints loadings, communalities, KMO, Bartlett, scores, ...
```

--------------------------------

### Complete example: Configure Insyra with custom settings

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/Configuration.md

Shows how to initialize Insyra with a custom log level, disable panics, and set a custom error handler before using the library. The example then creates a DataList and prints its mean. The custom error handler receives the error type, package, function, and message.

```go
package main

import (
    "fmt"
    "github.com/HazelnutParadise/insyra"
)

func main() {
    // Initialize with custom configuration
    insyra.Config.SetLogLevel(insyra.LogLevelDebug)
    insyra.Config.SetDontPanic(true)
    
    // Custom error handler
    insyra.Config.SetDefaultErrHandlingFunc(func(errType insyra.LogLevel, pkg, fn, msg string) {
        fmt.Printf("ERROR in %s.%s: %s\n", pkg, fn, msg)
    })
    
    // Now use Insyra with these settings
    dl := insyra.NewDataList(1, 2, 3, 4, 5)
    fmt.Println(dl.Mean())
}

```

--------------------------------

### version

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/cli-dsl.md

Shows the insyra version.

```APIDOC
## version

### Description
Shows the insyra version.

### Syntax
`version`
```

--------------------------------

### ChangeColName usage example

Source: https://github.com/hazelnutparadise/insyra/blob/main/Docs/DataTable.md

Example call to ChangeColName to rename a column.

```go
dt.ChangeColName("old_column_name", "new_column_name")
```
Tokens:
Raw