use super::Tensor;
use crate::error::Result;
impl Tensor {
pub fn mul_scalar(&self, scalar: f32) -> Result<Self> {
let scalar_tensor = self.broadcast_scalar(scalar)?;
self.mul(&scalar_tensor)
}
pub fn add_scalar(&self, scalar: f32) -> Result<Self> {
let scalar_tensor = self.broadcast_scalar(scalar)?;
self.add(&scalar_tensor)
}
pub fn div_scalar(&self, scalar: f32) -> Result<Self> {
self.mul_scalar(1.0 / scalar)
}
fn broadcast_scalar(&self, scalar: f32) -> Result<Self> {
let data = vec![scalar; self.len()];
Self::from_vec_on_sync(data, self.shape.clone(), self.device.clone())
}
pub async fn randn(shape: Vec<usize>) -> Result<Self> {
use rand::SeedableRng;
let mut rng = rand::rngs::StdRng::from_os_rng();
Self::randn_with_rng(shape, &mut rng).await
}
pub async fn randn_with_rng<R: rand::Rng>(shape: Vec<usize>, rng: &mut R) -> Result<Self> {
let size: usize = shape.iter().product();
let mut data = Vec::with_capacity(size);
for _ in 0..(size / 2) {
let u1: f32 = rng.random::<f32>().max(1e-10);
let u2: f32 = rng.random();
let r = (-2.0 * u1.ln()).sqrt();
let theta = 2.0 * std::f32::consts::PI * u2;
data.push(r * theta.cos());
data.push(r * theta.sin());
}
if size % 2 == 1 {
let u1: f32 = rng.random::<f32>().max(1e-10);
let u2: f32 = rng.random();
data.push((-2.0 * u1.ln()).sqrt() * (2.0 * std::f32::consts::PI * u2).cos());
}
data.truncate(size);
Self::from_vec(data, shape).await
}
pub async fn rand(shape: Vec<usize>) -> Result<Self> {
use rand::SeedableRng;
let mut rng = rand::rngs::StdRng::from_os_rng();
Self::rand_with_rng(shape, &mut rng).await
}
pub async fn rand_with_rng<R: rand::Rng>(shape: Vec<usize>, rng: &mut R) -> Result<Self> {
let size: usize = shape.iter().product();
let data: Vec<f32> = (0..size).map(|_| rng.random()).collect();
Self::from_vec(data, shape).await
}
pub async fn rand_range(shape: Vec<usize>, min: f32, max: f32) -> Result<Self> {
let uniform = Self::rand(shape).await?;
let range = max - min;
uniform.mul_scalar(range)?.add_scalar(min)
}
}