edubart

#include "complex.h"

#include <math.h>

typedef struct COMPLEX {
    float r, i;
} complex;

void comPrint(complex a);
complex comMul(complex a, complex b);

edubart

#!/bin/bash
cd /tmp
sudo apt-get -y install kdelibs5-dev kdebase-workspace-dev
git clone git://anongit.kde.org/kdevplatform
cd kdevplatform
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=/usr
make -j8
sudo make install
kbuildsycoca4

edubart

#!/bin/bash

interface=eth0
address=
gateway=
broadcast=
netmask=
vpn_local=10.0.0.1
vpn_remote=10.0.0.2
ssh_user=root

edubart

require 'torch'
_ = require 'moses'
csv2tensor = require 'csv2tensor'

local dataset = csv2tensor.load('pima-indians-diabetes.data')
local trainRatio = 0.67

local dataSize = dataset:size(1)
local trainSize = torch.floor(dataSize * trainRatio)
local testSize = dataSize - trainSize

edubart

#ifndef LINEARREGRESSION_H
#define LINEARREGRESSION_H

#include "global.h"

class LinearRegression
{
public:
    void fit(arma::mat X, const arma::mat& y, double alpha = 0.1, ulong numIterations = 500) {
        prepareNormalization(X, mu, sigma);

edubart

% O primo 41 pode ser escrito como a soma de 6 primos consecutivos
% 41 = 2 + 3 + 5 + 7 + 11 + 13

% Essa eh a a soma mais longa de primos consecutivos menor
% que 100 em que resulta em tambem em um numero primo, ela contem 6 termos

% A soma mais longa de primos consecutivos menor que 1000 em que resulta
% um numero primo eh 953 com 21 termos
%
% Qual primo menor que 1 milhao pode ser escrito como a soma mais longa

edubart

Environment:

• Ubuntu 16.04 LTS
• Intel(R) Core(TM) i7-3770K CPU @ 3.50GHz
• Nim Compiler Version 0.14.3 (2016-06-17) [Linux: amd64]
• node v5.10.1

Nim code:

import asynchttpserver, asyncdispatch

edubart

import ../src/arraymancer
import math

proc `/`*[T: SomeNumber](a: T, t: Tensor[T]): Tensor[T] {.noSideEffect.} =
  return t.fmap(proc(x: T): T = a / x)

proc `+`*[T: SomeNumber](t: Tensor[T], a: T): Tensor[T] {.noSideEffect.} =
  return t.fmap(proc(x: T): T = x + a)

proc `+`*[T: SomeNumber](a: T, t: Tensor[T]): Tensor[T] {.noSideEffect.} =

edubart

# Seq of tensors to tensor
proc toTensor*[T](s: openarray[Tensor[T]]): Tensor[T] =
  s.map(proc(t: Tensor[T]): Tensor[T] = t.unsafeUnsqueeze(0)).concat(0)

# Make universal does not work with abs
proc abs*[T](t: Tensor[T]): Tensor[T] =
  t.map(proc(x: T):T = abs(x))

# Seq to reshaped tensor, no copy
proc unsafeToTensorReshape[T](data: seq[T], shape: openarray[int]): Tensor[T] {.noSideEffect.} =

edubart

########## Shape Array
const MAXRANK* = 8

type
  ShapeArray* = object
    data: array[MAXRANK, int]
    len: int

proc newShapeArray*(len: int): ShapeArray {.inline.} =