Feature/99 core tensors

.github/worklfows/build.yml

@@ -0,0 +1,32 @@
+name: Build Feature Branch Apk
+
+on: [ push, pull_request ]
+
+jobs:
+  build-job:
+    runs-on: ubuntu-latest # enables hardware acceleration in the virtual machine
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Copy CI gradle.properties
+        run: mkdir -p ~/.gradle ; cp .github/ci-gradle.properties ~/.gradle/gradle.properties
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: 17
+
+
+      - name: Print git commit variables
+        run: |
+          echo "TAG: $CURRENT_TAG"
+
+      - name: Copy CI gradle.properties
+        run: mkdir -p ~/.gradle ; cp .github/ci-gradle.properties ~/.gradle/gradle.properties
+
+      - name: Build
+        run: ./gradlew --stacktrace clean assemble allTests

.github/worklfows/publish.yml

@@ -0,0 +1,26 @@
+name: release
+
+on:
+  push:
+    tags:
+      - '**'
+
+jobs:
+  publish:
+    name: Release build and publish
+    runs-on: macOS-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v5
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'zulu'
+          java-version: 21
+      - name: Publish to MavenCentral
+        run: ./gradlew publish --no-configuration-cache --stacktrace
+        env:
+          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
+          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
+          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_PRIVATE_KEY }}
+          ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}

GITFLOW.adoc

@@ -5,7 +5,7 @@
 :sectlinks:
 :source-highlighter: highlight.js
 
-This document describes the GitFlow workflow used in the skainet project for managing feature development, releases, and hotfixes.
+This document describes the GitFlow workflow used in the SKaiNET project for managing feature development, releases, and hotfixes.
 
 == Overview
 
@@ -309,6 +309,6 @@ git reset --hard HEAD~1
 
 == Conclusion
 
-GitFlow provides a structured approach to managing code changes in collaborative environments. By following this workflow consistently, the skainet project maintains code quality, enables parallel development, and ensures stable releases.
+GitFlow provides a structured approach to managing code changes in collaborative environments. By following this workflow consistently, the SKaiNET project maintains code quality, enables parallel development, and ensures stable releases.
 
 For questions or clarifications about this workflow, please refer to the original https://nvie.com/posts/a-successful-git-branching-model/[GitFlow article] or reach out to the project maintainers.

README.adoc

@@ -1,6 +1,6 @@
-= skainet
+= SKaiNET
 
-*skainet* is an open-source deep learning framework written in Kotlin, designed with developers in mind to enable the creation modern AI powered applications with ease.
+*SKaiNET* is an open-source deep learning framework written in Kotlin, designed with developers in mind to enable the creation modern AI powered applications with ease.
 
 == Development Practices
 

build.gradle.kts

@@ -2,18 +2,10 @@ plugins {
     alias(libs.plugins.androidLibrary) apply false
     alias(libs.plugins.kotlinMultiplatform) apply  false
     alias(libs.plugins.jetbrainsKotlinJvm) apply false
-    alias(libs.plugins.binaryCompatibility) apply false
-    alias(libs.plugins.modulegraph.souza) apply true
-
-
+    alias(libs.plugins.vanniktech.mavenPublish) apply false
 }
 
 allprojects {
     group = "sk.ai.net"
     version = "0.0.7"
-}
-
-moduleGraphConfig {
-    readmePath.set("./Modules.md")
-    heading = "### Module Graph"
-}
+}

docs/antora.yml

@@ -0,0 +1,7 @@
+name: skainet
+title: Skainet Deep Learning Framework
+version: '1.0'
+nav:
+- modules/getting-started/nav.adoc
+- modules/ROOT/nav.adoc
+- modules/arc42/nav.adoc

docs/modules/ROOT/nav.adoc

@@ -0,0 +1,14 @@
+= SKaiNET Architecture Documentation
+
+* xref:01-introduction-and-goals.adoc[Introduction and Goals]
+* xref:02-architecture-constraints.adoc[Architecture Constraints]
+* xref:03-context-and-scope.adoc[Context and Scope]
+* xref:04-solution-strategy.adoc[Solution Strategy]
+* xref:05-building-block-view.adoc[Building Block View]
+* xref:06-runtime-view.adoc[Runtime View]
+* xref:07-deployment-view.adoc[Deployment View]
+* xref:08-crosscutting-concepts.adoc[Crosscutting Concepts]
+* xref:09-architecture-decisions.adoc[Architecture Decisions]
+* xref:10-quality-requirements.adoc[Quality Requirements]
+* xref:11-risks-and-technical-debt.adoc[Risks and Technical Debt]
+* xref:12-glossary.adoc[Glossary]

docs/modules/arc42/nav.adoc

@@ -0,0 +1,14 @@
+= Skainet Architecture Documentation
+
+* xref:01-introduction-and-goals.adoc[Introduction and Goals]
+* xref:02-architecture-constraints.adoc[Architecture Constraints]
+* xref:03-context-and-scope.adoc[Context and Scope]
+* xref:04-solution-strategy.adoc[Solution Strategy]
+* xref:05-building-block-view.adoc[Building Block View]
+* xref:06-runtime-view.adoc[Runtime View]
+* xref:07-deployment-view.adoc[Deployment View]
+* xref:08-crosscutting-concepts.adoc[Crosscutting Concepts]
+* xref:09-architecture-decisions.adoc[Architecture Decisions]
+* xref:10-quality-requirements.adoc[Quality Requirements]
+* xref:11-risks-and-technical-debt.adoc[Risks and Technical Debt]
+* xref:12-glossary.adoc[Glossary]

docs/modules/arc42/pages/01-introduction-and-goals.adoc

@@ -0,0 +1,81 @@
+= Introduction and Goals
+
+[role="arc42help"]
+****
+Describes the relevant requirements and the driving forces that software architects and development team must consider. 
+These include
+
+* underlying business goals, 
+* essential features, 
+* essential functional requirements, 
+* quality goals for the architecture and
+* relevant stakeholders and their expectations
+****
+
+== Requirements Overview
+
+=== What is SKaiNET?
+
+SKaiNET is an open-source deep learning framework written in Kotlin, designed with developers in mind to enable the creation of modern AI-powered applications with ease. The framework provides a comprehensive tensor computation system with multiple backend support for different hardware platforms.
+
+=== Key Features
+
+* *Multi-dimensional Tensor Operations*: Complete support for tensor mathematics including matrix multiplication, element-wise operations, and broadcasting
+* *Pluggable Backend Architecture*: Abstracted computation backends allowing CPU, GPU, and other hardware-specific implementations
+* *Type-Safe API*: Kotlin-based type-safe tensor operations with compile-time shape and type checking
+* *Performance Optimizations*: Built-in performance measurement and benchmarking framework for optimization analysis
+* *Multiplatform Support*: Kotlin Multiplatform compatibility for cross-platform deployment
+
+== Quality Goals
+
+[options="header",cols="1,2,2"]
+|===
+| Priority | Quality Goal | Motivation
+
+| 1
+| Performance
+| Enable high-performance tensor computations competitive with established frameworks like TensorFlow and PyTorch
+
+| 2
+| Type Safety
+| Leverage Kotlin's type system to catch tensor shape and type mismatches at compile time
+
+| 3
+| Extensibility
+| Support pluggable backends for different hardware platforms (CPU, GPU, TPU, etc.)
+
+| 4
+| Developer Experience
+| Provide intuitive, Kotlin-idiomatic APIs that are easy to learn and use
+
+| 5
+| Cross-platform Compatibility
+| Support deployment across JVM, Android, Native, and JavaScript platforms
+|===
+
+== Stakeholders
+
+[options="header",cols="1,2,2"]
+|===
+| Role/Name | Contact | Expectations
+
+| AI/ML Developers
+| Primary users
+| Easy-to-use, performant tensor operations with good documentation
+
+| Backend Engineers
+| System integrators
+| Stable, well-tested APIs for building AI-powered applications
+
+| Platform Engineers
+| Infrastructure teams
+| Efficient resource utilization and good observability
+
+| Framework Contributors
+| Open source community
+| Clear architecture, good test coverage, contribution guidelines
+
+| Research Scientists
+| Academic/industry researchers
+| Flexibility for experimental algorithms and custom operations
+|===

docs/modules/arc42/pages/02-architecture-constraints.adoc

@@ -0,0 +1,75 @@
+= Architecture Constraints
+
+[role="arc42help"]
+****
+Any requirement that constrains software architects in their freedom of design and implementation decisions or decision about the development process. These constraints sometimes go beyond individual systems and are valid for whole organizations and companies.
+****
+
+== Technical Constraints
+
+[options="header",cols="1,3,2"]
+|===
+| Constraint | Description | Background
+
+| Kotlin Multiplatform
+| Framework must be implemented in Kotlin and support multiplatform deployment (JVM, Native, JS)
+| Enables cross-platform compatibility and leverages Kotlin's type safety features
+
+| Memory Management
+| Must work efficiently within JVM garbage collection and native memory constraints
+| Critical for performance in tensor operations with large data arrays
+
+| No External Dependencies
+| Core tensor operations should minimize external dependencies
+| Reduces complexity, improves security, and enables easier deployment
+
+| Backward Compatibility
+| API changes must maintain backward compatibility following semantic versioning
+| Ensures stable integration for dependent applications and libraries
+|===
+
+== Organizational Constraints
+
+[options="header",cols="1,3,2"]
+|===
+| Constraint | Description | Background
+
+| Open Source License
+| Must use permissive open source license (likely Apache 2.0 or MIT)
+| Enables broad adoption in commercial and academic contexts
+
+| GitFlow Development
+| Development follows GitFlow branching model with feature branches
+| Ensures structured release management and code quality
+
+| Test-Driven Development
+| All features must have comprehensive test coverage including benchmarks
+| Maintains code quality and performance regression detection
+
+| Documentation Standards
+| All public APIs must be documented with KDoc and architecture with Arc42
+| Ensures maintainability and ease of adoption
+|===
+
+== Conventions
+
+[options="header",cols="1,3,2"]
+|===
+| Convention | Description | Rationale
+
+| Semantic Versioning
+| Follows SemVer (MAJOR.MINOR.PATCH) for all releases
+| Provides clear expectations about API changes and compatibility
+
+| Kotlin Coding Standards
+| Adheres to official Kotlin coding conventions and style guide
+| Ensures consistent, readable codebase across all modules
+
+| Performance Benchmarking
+| All core operations must include performance benchmarks
+| Enables performance regression detection and optimization tracking
+
+| Type Safety First
+| Leverages Kotlin's type system for compile-time error detection
+| Reduces runtime errors and improves developer experience
+|===