using Pkg
Pkgg.add(url="https://github.com/arungeorgesaji/lattice")

using Lattice


# Create grids
zeros  = Lattice.zeros_grid(3, 3)
ones  = Lattice.ones_grid(3, 3)
random  = Lattice.random_grid(3, 3)


# Grid arithmetic
result  = ones + random * 2
scaled  = result / 3


# Element-wise operations
mapped  = Lattice.map_grid(x ->gt; x^2, ones)
transformed  = Lattice.transform(random, x ->gt; sin(x))


# Indexing and iteration
value  = result[1, 1]

for element in result
     println(element)

end

using Lattice


# Build a sequential model
model  = Lattice.NN.Sequential(
    Latticee.NN.DenseLayer(784, 128),
    Latticee.NN.relu,
    Latticee.NN.DenseLayer(128, 64),
    Latticee.NN.relu,
    Latticee.NN.DenseLayer(64, 10),
    Latticee.NN.sigmoid
)



# Forward pass
input  = Lattice.random_grid(784, 1)
output  = model(input)


# CNN for image classification
cnn  = Lattice.NN.Sequential(
    Latticee.NN.ConvLayer(1, 16, 3),
    Latticee.NN.relu,
    Latticee.NN.MaxPool(2),
    Latticee.NN.ConvLayer(16, 32, 3),
    Latticee.NN.relu,
    Latticee.NN.GlobalAvgPool(),
    Latticee.NN.DenseLayer(32, 10)
)



# Training with optimizers
optimizer  = Lattice.NN.Adam(0.001)
loss  = Lattice.NN.mse_loss(predictions, targets)


# Update parameters

for param in Lattice.NN.get_parameters(model)
    gradient  = compute_gradient(param)  # Your gradient computation
    Latticee.NN.update!(optimizer, param, gradient)

end

# Load or create an image
image  = Lattice.Grid(rand(256, 256))


# Apply blur
blurred  = Lattice.blur_image(image, kernel_size=5)


# Edge detection
edges  = Lattice.edge_detect_image(image)


# Custom convolution
kernel  = Lattice.blur_kernel(3)
result  = Lattice.convolve(image, kernel)


# Visualization
Latticee.show_ascii(image)
Latticee.show_comparison(image, blurred)

result_valid = Lattice.convolve(image, kernel, mode=:valid)  # Smaller output
result_same  = Lattice.convolve(image, kernel, mode=:same)    # Same size as input

using Lattice


# Generate audio
sine_wave  = Lattice.Audio.generate_sine_wave(440.0, duration=1.0, sample_rate=44100)


# Process audio
normalized  = Lattice.Audio.normalize_audio(sine_wave)
amplified  = Lattice.Audio.apply_gain(sine_wave, 6.0)  # +6 dB


# Extract features
rms_energy  = Lattice.Audio.compute_rms(sine_wave)
zero_crossings  = Lattice.Audio.zero_crossing_rate(sine_wave)

using Lattice


# Character encoding
text  = "hello world"
grid  = Lattice.text_to_grid(text, method=:character)
reconstructed  = Lattice.grid_to_text(grid, method=:character)


# One-hot encoding
vocab  = ['h', 'e', 'l', 'o', 'w', 'r', 'd', ' ']
one_hot  = Lattice.text_to_grid(text, method=:one_hot, vocab=vocab)


# Sliding windows for sequence processing
windows  = Lattice.text_sliding_window(text, window_size=5)


# Text similarity
grid1  = Lattice.text_to_grid("hello", method=:character)
grid2  = Lattice.text_to_grid("hello", method=:character)
similarity  = Lattice.text_similarity(grid1, grid2)  # Returns 1.0

using Lattice


# Fluid dynamics
fluid  = Lattice.Physics.FluidSimulation(50, 50)
Latticee.Physics.add_density!(fluid, 25, 25, 1.0)
diffused  = Lattice.Physics.diffuse!(fluid.density, 0.1, 0.1)


# Heat diffusion
temperature  = Lattice.zeros_grid(100, 100)
temperaturee.data[50, 50] = 100.0
cooled  = Lattice.Physics.heat_diffusion(temperature, diffusivity=0.1, steps=50)


# Particle systems with gravity
system  = Lattice.Physics.ParticleSystem(100, width=50, height=50)
Latticee.Physics.step!(system, dt=0.1)
particle_grid  = Lattice.Physics.particles_to_grid(system)


# Cellular automata (Conway's Game of Life)
initial  = Lattice.zeros_grid(20, 20)
initiall.data[10, 9:11] .= 1.0  # Horizontal line (blinker)
evolved  = Lattice.Physics.game_of_life(initial, generations=10)

using Lattice


# 2D Shape Generation
circle  = Lattice.Graphics.create_circle(radius=5, center_x=10, center_y=10, grid_size=(20, 20))
rectangle  = Lattice.Graphics.create_rectangle(width=8, height=6, start_x=5, start_y=5, grid_size=(20, 20))
line  = Lattice.Graphics.create_line(x1=2, y1=2, x2=18, y2=18, grid_size=(20, 20))


# 3D Voxel Operations
voxel_sphere  = Lattice.Graphics.create_sphere_voxel(radius=4, center=(8, 8, 8), grid_size=(16, 16, 16))
voxel_cube  = Lattice.Graphics.create_cube_voxel(size=5, start=(3, 3, 3), grid_size=(16, 16, 16))


# Ray Marching for 3D Rendering
sphere_render  = Lattice.Graphics.ray_march_sdf(Lattice.Graphics.sphere_sdf, resolution=64, max_distance=3.0)
box_render  = Lattice.Graphics.ray_march_sdf(Lattice.Graphics.box_sdf, resolution=64, max_distance=3.0)


# 2D Transformations
rotated  = Lattice.Graphics.rotate_2d(circle, angle=π/4)  # 45 degrees
scaled  = Lattice.Graphics.scale_2d(circle, scale_x=1.5, scale_y=1.5)


# Pattern Generation
checkerboard  = Lattice.Graphics.create_checkerboard(size=16, square_size=4)
gradient  = Lattice.Graphics.create_gradient(size=16, direction=:vertical)


# Morphological Operations
dilated  = Lattice.Graphics.dilate(circle, kernel_size=3)
eroded  = Lattice.Graphics.erode(circle, kernel_size=3)


# Visualization
Latticee.show_ascii(circle)
Latticee.show_comparison(circle, rotated, titles=["Original", "Rotated"])

# Save grids
grid  = Lattice.random_grid(100, 100)
Latticee.save_grid(grid, "data.bin")           # Binary format
Latticee.save_grid_text(grid, "data.txt")       # Text format


# Load grids
loaded_binary  = Lattice.load_grid("data.bin")
loaded_text  = Lattice.load_grid_text("data.txt")