/**
 * Copyright (c) 2020 CEA LIST
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 * 
 */
package org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers;


/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Recurrent layers 1</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getNum_layers <em>Num layers</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isBatch_first_pt <em>Batch first pt</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getDropout <em>Dropout</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isBidirectional_pt <em>Bidirectional pt</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getActivation <em>Activation</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_activation <em>Recurrent activation</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isUse_bias <em>Use bias</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getKernel_initializer <em>Kernel initializer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_initializer <em>Recurrent initializer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getBias_initializer <em>Bias initializer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isReturn_sequences <em>Return sequences</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isReturn_state <em>Return state</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getBidirectional_k <em>Bidirectional k</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_dropout <em>Recurrent dropout</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1()
 * @model abstract="true"
 * @generated
 */
public interface Recurrent_layers_1 extends Recurrent_layers {
	/**
	 * Returns the value of the '<em><b>Num layers</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Num layers</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Num layers</em>' attribute.
	 * @see #setNum_layers(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Num_layers()
	 * @model dataType="org.eclipse.uml2.types.Integer" ordered="false"
	 * @generated
	 */
	int getNum_layers();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getNum_layers <em>Num layers</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Num layers</em>' attribute.
	 * @see #getNum_layers()
	 * @generated
	 */
	void setNum_layers(int value);

	/**
	 * Returns the value of the '<em><b>Batch first pt</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Batch first pt</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Batch first pt</em>' attribute.
	 * @see #setBatch_first_pt(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Batch_first_pt()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isBatch_first_pt();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isBatch_first_pt <em>Batch first pt</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Batch first pt</em>' attribute.
	 * @see #isBatch_first_pt()
	 * @generated
	 */
	void setBatch_first_pt(boolean value);

	/**
	 * Returns the value of the '<em><b>Dropout</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Dropout</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Dropout</em>' attribute.
	 * @see #setDropout(double)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Dropout()
	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
	 * @generated
	 */
	double getDropout();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getDropout <em>Dropout</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Dropout</em>' attribute.
	 * @see #getDropout()
	 * @generated
	 */
	void setDropout(double value);

	/**
	 * Returns the value of the '<em><b>Bidirectional pt</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bidirectional pt</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bidirectional pt</em>' attribute.
	 * @see #setBidirectional_pt(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Bidirectional_pt()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isBidirectional_pt();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isBidirectional_pt <em>Bidirectional pt</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bidirectional pt</em>' attribute.
	 * @see #isBidirectional_pt()
	 * @generated
	 */
	void setBidirectional_pt(boolean value);

	/**
	 * Returns the value of the '<em><b>Activation</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Activation</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Activation</em>' attribute.
	 * @see #setActivation(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Activation()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getActivation();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getActivation <em>Activation</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Activation</em>' attribute.
	 * @see #getActivation()
	 * @generated
	 */
	void setActivation(String value);

	/**
	 * Returns the value of the '<em><b>Recurrent activation</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Recurrent activation</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Recurrent activation</em>' attribute.
	 * @see #setRecurrent_activation(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Recurrent_activation()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getRecurrent_activation();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_activation <em>Recurrent activation</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Recurrent activation</em>' attribute.
	 * @see #getRecurrent_activation()
	 * @generated
	 */
	void setRecurrent_activation(String value);

	/**
	 * Returns the value of the '<em><b>Use bias</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Use bias</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Use bias</em>' attribute.
	 * @see #setUse_bias(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Use_bias()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isUse_bias();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isUse_bias <em>Use bias</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Use bias</em>' attribute.
	 * @see #isUse_bias()
	 * @generated
	 */
	void setUse_bias(boolean value);

	/**
	 * Returns the value of the '<em><b>Kernel initializer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Kernel initializer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Kernel initializer</em>' attribute.
	 * @see #setKernel_initializer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Kernel_initializer()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getKernel_initializer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getKernel_initializer <em>Kernel initializer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Kernel initializer</em>' attribute.
	 * @see #getKernel_initializer()
	 * @generated
	 */
	void setKernel_initializer(String value);

	/**
	 * Returns the value of the '<em><b>Recurrent initializer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Recurrent initializer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Recurrent initializer</em>' attribute.
	 * @see #setRecurrent_initializer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Recurrent_initializer()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getRecurrent_initializer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_initializer <em>Recurrent initializer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Recurrent initializer</em>' attribute.
	 * @see #getRecurrent_initializer()
	 * @generated
	 */
	void setRecurrent_initializer(String value);

	/**
	 * Returns the value of the '<em><b>Bias initializer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bias initializer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bias initializer</em>' attribute.
	 * @see #setBias_initializer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Bias_initializer()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getBias_initializer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getBias_initializer <em>Bias initializer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bias initializer</em>' attribute.
	 * @see #getBias_initializer()
	 * @generated
	 */
	void setBias_initializer(String value);

	/**
	 * Returns the value of the '<em><b>Return sequences</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Return sequences</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Return sequences</em>' attribute.
	 * @see #setReturn_sequences(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Return_sequences()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isReturn_sequences();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isReturn_sequences <em>Return sequences</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Return sequences</em>' attribute.
	 * @see #isReturn_sequences()
	 * @generated
	 */
	void setReturn_sequences(boolean value);

	/**
	 * Returns the value of the '<em><b>Return state</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Return state</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Return state</em>' attribute.
	 * @see #setReturn_state(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Return_state()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isReturn_state();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#isReturn_state <em>Return state</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Return state</em>' attribute.
	 * @see #isReturn_state()
	 * @generated
	 */
	void setReturn_state(boolean value);

	/**
	 * Returns the value of the '<em><b>Bidirectional k</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bidirectional k</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bidirectional k</em>' reference.
	 * @see #setBidirectional_k(Recurrent_layers_1)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Bidirectional_k()
	 * @model ordered="false"
	 * @generated
	 */
	Recurrent_layers_1 getBidirectional_k();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getBidirectional_k <em>Bidirectional k</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bidirectional k</em>' reference.
	 * @see #getBidirectional_k()
	 * @generated
	 */
	void setBidirectional_k(Recurrent_layers_1 value);

	/**
	 * Returns the value of the '<em><b>Recurrent dropout</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Recurrent dropout</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Recurrent dropout</em>' attribute.
	 * @see #setRecurrent_dropout(double)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layersPackage#getRecurrent_layers_1_Recurrent_dropout()
	 * @model dataType="org.eclipse.uml2.types.Real" required="true" ordered="false"
	 * @generated
	 */
	double getRecurrent_dropout();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Recurrent_layers.Recurrent_layers_1#getRecurrent_dropout <em>Recurrent dropout</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Recurrent dropout</em>' attribute.
	 * @see #getRecurrent_dropout()
	 * @generated
	 */
	void setRecurrent_dropout(double value);

} // Recurrent_layers_1
